@uipath/maestro-builder-sdk 6.21.2 → 6.23.0

package/dist/core/actions.d.ts

@@ -10,141 +10,6 @@
 import type { Expr } from './expr.js';
 import type { LookupToken } from './lookups.js';
 import { type ConnectorDescriptor, type TriggerDescriptor } from './connectors.js';
-/** One conditional response branch on an HTTP node — a designer-visible side exit. */
-export interface HttpBranch {
-    /**
-     * The branch's name — it becomes the node's `branch-<name>` source port, so
-     * keep it port-safe (letters, digits, `_`, `-`). Route it with
-     * `.stepToList('branch-<name>', ...)` after the step; the main path continues
-     * from the default port as always.
-     */
-    name: string;
-    /**
-     * When to take this exit, evaluated against the response — e.g.
-     * js-tagged: `$vars.fetch.output.statusCode === 429`. Branches are checked in
-     * order; the first truthy one wins, else the default port fires.
-     */
-    condition: Expr;
-}
-interface HttpInputsBase {
-    /**
-     * Conditional response branches — extra source ports (`branch-<name>`)
-     * beside the default. See {@link HttpBranch}; both HTTP node families
-     * declare them.
-     */
-    branches?: HttpBranch[];
-    method?: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
-    url: string | Expr;
-    headers?: Record<string, string | Expr>;
-    query?: Record<string, string | Expr>;
-    body?: string | Expr;
-    contentType?: string;
-    /**
-     * Choose the HTTP node explicitly. `false` emits the standalone
-     * `core.action.http`; `true` emits the managed `core.action.http.v2`, routed
-     * through Integration Service's HTTP connector.
-     *
-     * This has no default because these are different platform nodes, not two
-     * modes of one node. A silent `false` made an omitted field compile and
-     * validate as the wrong node while changing failure routing and connection
-     * behavior.
-     *
-     * It is not a version bump, it changes two things you can see:
-     *
-     * - **a 4xx/5xx FAILS the step**, so `.onError(…)` fires on it. On the plain
-     *   node the same 404 comes back on the SUCCESS path as
-     *   `out('fetch','statusCode')` and no error handler ever runs — which is why
-     *   an error port only makes sense here (`check` says so: HTTP_ONERROR_V1).
-     *   The handler can answer the flow (`.return`), stop the run
-     *   (`.terminate`), or compensate and continue at a step the success path
-     *   also reaches (`h.stepToRef('<step>')` — see `references/error-handling.md`);
-     * - both nodes expose JSON responses as parsed values in the live product;
-     *   use `returns` to declare fields before reading them. The node choice does
-     *   not decide whether application/json is parsed.
-     *
-     * With `managed: true`, omit `connection` and `folder` for the platform's
-     * manual/implicit mode, or provide both symbolic names to reuse an Integration
-     * Service HTTP connection. A local run remains unauthenticated.
-     *
-     * @enforcedBy HTTP_ONERROR_V1 `.onError()` on an http step needs `managed: true`; on
-     * the standalone node a 4xx arrives on the SUCCESS path and no handler runs.
-     */
-    managed: boolean;
-    /**
-     * The response BODY's top-level fields and their types — e.g.
-     * `{ items: 'array' }`. Required for either HTTP node if anything reads a
-     * field off a parsed JSON body.
-     *
-     * Why you have to say: the platform's own definition declares the response as
-     * a bare object, because only the API being called knows its shape. Without
-     * this, `out('fetch','body','items')` reads from an object with no declared
-     * fields, and nothing downstream can tell a real field from a typo. Same rule,
-     * and the same word, as
-     * `rpaWorkflow`'s `returns`.
-     *
-     * **Where a declared field is read:** under `body`, never beside it. The
-     * response is an envelope — `{ body, statusCode, headers }` — and these are the
-     * body's fields, so `returns: { items: 'array' }` is read as
-     * `out('fetch', 'body.items')`, which is `$vars.fetch.output.body.items`.
-     * `$vars.fetch.output.items` is undefined at run time.
-     *
-     * @enforcedBy HTTP_READ_UNKNOWN_FIELD A read must be `output.body.<declared field>`,
-     * `output.statusCode` or `output.headers`.
-     * @enforcedBy HTTP_READ_WITHOUT_RETURNS Reading a body field requires declaring it here.
-     */
-    returns?: Record<string, ReturnFieldType>;
-    /**
-     * How long to wait for the response before giving up, as an **ISO-8601
-     * duration** — `'PT30S'` is "give up after 30 seconds", `'PT1M'` one minute,
-     * `'PT15M'` fifteen.
-     *
-     * Both http node types carry this, and both definitions declare the same
-     * default (`PT15M`), so leaving it unset is not "no timeout" — it is fifteen
-     * minutes. Omitted from the emitted node unless you set it, which keeps a flow
-     * that doesn't care byte-identical to the platform's own default shape (~99%
-     * of the 808 deployed http nodes are on the defaults).
-     *
-     * `check` rejects a string the platform cannot parse as a duration —
-     * `'30s'`, `'PT'` and `'30'` are all errors that name the expected form.
-     *
-     * @defaultValue `'PT15M'`
-     * @enforcedBy HTTP_TIMEOUT_NOT_DURATION Must be an ISO-8601 duration.
-     */
-    timeout?: string;
-    /**
-     * How many times to RETRY a retryable failure (5xx, 429, a network error) —
-     * `0`, the definitions' default, means "try once, don't retry". `2` means up
-     * to three attempts in total.
-     *
-     * Must be a non-negative integer. Above **5** `check` warns rather than
-     * errors: the deployed corpus's
-     * largest author-set value is 3, and the platform's own ceiling is not
-     * measured — so a bigger number may well work, and refusing it outright would
-     * fence off something we have no evidence is wrong.
-     *
-     * @defaultValue `0`
-     * @enforcedBy HTTP_RETRY_COUNT_INVALID Must be a non-negative integer.
-     */
-    retryCount?: number;
-}
-export type HttpInputs = HttpInputsBase & ({
-    managed: false;
-    connection?: never;
-    folder?: never;
-} | {
-    managed: true;
-    /** Symbolic HTTP connection name declared in bindings.json. */
-    connection?: string;
-    /** Symbolic folder name declared in bindings.json. */
-    folder?: string;
-    /**
-     * Connector key whose authentication the HTTP proxy should reuse.
-     * Defaults to `uipath-uipath-http`. Set this for a connector-specific
-     * fallback endpoint, for example `uipath-salesforce-slack`.
-     * Requires both `connection` and `folder`.
-     */
-    targetConnector?: string;
-});
 export interface ConnectorOpts {
     /** Connector action version (defaults to the library's newest match). */
     version?: string;
@@ -671,62 +536,6 @@ export interface VoiceAgentInputs {
      */
     source?: string;
 }
-export interface SummarizeInputs {
-    /**
-     * The document to summarize — a whole **Flow Attachment** object
-     * (`{ ID, FullName, MimeType, Metadata }`), not a path, id or URL.
-     *
-     * In practice that is a `file`-typed flow input:
-     *
-     * ```ts
-     * flow('SummarizeDemo')
-     *   .input({ documentFile: types.file })
-     *   .step('summarizeContract', summarize({ attachment: input('documentFile'), … }))
-     * ```
-     *
-     * `out('start', 'documentFile')` is the same value written the way the CANVAS
-     * writes it (`$vars.start.output.documentFile`, resolved through the input's
-     * `triggerNodeId` binding). Both forms run — measured on the real service —
-     * so prefer whichever the task asks for; `out('start', …)` is what a
-     * designer-made flow looks like.
-     *
-     * The service reads the file's CONTENT, and refuses one it cannot treat as a
-     * document: a PDF summarizes, a plain `.txt` comes back
-     * `[460005] … "No valid files to use for Summarization."`
-     */
-    attachment: Expr;
-    /** What the summary should cover, e.g. `'Write a 5-bullet executive summary…'`. */
-    prompt: string | Expr;
-    /**
-     * Ask the service for per-claim citations. Each is
-     * `{ Ordinal, PageNumber, Source, Reference }` and lands in
-     * `out('<step>', 'content.Citations')`. Defaults to `false`.
-     */
-    returnCitations?: boolean;
-}
-/** One column Batch Transform appends to the CSV. */
-export interface OutputColumn {
-    /** The new column's header, e.g. `'Category'`. */
-    name: string;
-    /** What the model should put in it, e.g. `'One of: Utility, Software, Travel, Other'`. */
-    description: string;
-}
-export interface BatchTransformInputs {
-    /**
-     * The CSV to enrich — a whole **Flow Attachment** object, same shape and same
-     * two ways of referencing it as {@link SummarizeInputs.attachment}.
-     */
-    attachment: Expr;
-    /** How to process each row, e.g. `'Classify each row and write a one-line summary.'`. */
-    prompt: string | Expr;
-    /**
-     * The columns to add, in order. The node's own field name — an array of
-     * `{ name, description }`, one per new column.
-     */
-    outputColumns: OutputColumn[];
-    /** Let the model use web search while transforming. Defaults to `false`. */
-    enableWebSearchGrounding?: boolean;
-}
 /**
  * Split an extractor's node type into the two GUIDs its tail packs.
  *
@@ -1928,10 +1737,6 @@ export interface ContextIndexRef {
  * whole body rather than an inputs payload.
  */
 export interface FlowActionSpecs {
-    /** The spec {@link http} builds. */
-    http: {
-        inputs: HttpInputs;
-    };
     /** The spec {@link hitl} builds. */
     hitl: {
         inputs: HitlInputs;
@@ -1988,14 +1793,6 @@ export interface FlowActionSpecs {
     inlineAgent: {
         inputs: InlineAgentInputs;
     };
-    /** The spec {@link summarize} builds. */
-    summarize: {
-        inputs: SummarizeInputs;
-    };
-    /** The spec {@link batchTransform} builds. */
-    batchTransform: {
-        inputs: BatchTransformInputs;
-    };
     /** The spec {@link ixpExtract} builds. */
     ixpExtract: {
         inputs: IxpExtractInputs;
@@ -2059,14 +1856,6 @@ export declare function builtinActionSpec<S extends object>(spec: S): S;
  * @returns The same spec, as a `FlowTrigger` instance.
  */
 export declare function builtinTriggerSpec<S extends object>(spec: S): S;
-/**
- * Declare an HTTP request action, explicitly choosing standalone or managed.
- *
- * @param inputs - The request: `url`, `method`, `body`, the response fields you
- * read back via `returns`, and the `managed` node choice.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function http(inputs: HttpInputs): ActionSpec;
 /**
  * Declare a human task — a step that pauses for a person to read some values,
  * fill others in, and press one of the outcome buttons.
@@ -2119,82 +1908,6 @@ export declare function http(inputs: HttpInputs): ActionSpec;
  * @example example-eval/GallerySubmission.flow.ts
  */
 export declare function hitl(inputs: HitlInputs): ActionSpec;
-/**
- * Summarize a document with citations — the platform's **Summarize** node.
- *
- * @remarks
- * **The node type is `uipath.pattern.deep-rag`.** The canvas calls it
- * *Summarize*, its properties panel is titled *Summarize Configuration*, and
- * the wire type stays `deep-rag` — it is the same node, under the name the
- * backend service contract uses (`ECS.DeepRag`). There is no
- * `uipath.pattern.summarize`. (A same-named inline-agent TOOL,
- * `uipath.agent.resource.tool.builtin.summarize`, is a different family.)
- *
- * The answer's fields are **PascalCase** — `content.Text`,
- * `content.Citations[].{Ordinal, PageNumber, Source, Reference}`. Lowercase
- * `content.text` resolves to nothing at run time.
- *
- * A local run cannot reach the service: it returns the baked
- * fixture shape, and only a real platform run (`uip maestro flow debug
- * --attachment <var>=<file>`) calls the model.
- *
- * @example
- * **Summarize an attached contract, with citations**
- * ```ts
- * flow('SummarizeDemo')
- *   .input({ documentFile: types.file })
- *   .output({ summary: types.string, citations: types.array })
- *   .step('summarizeContract', summarize({
- *     attachment: out('start', 'documentFile'),
- *     prompt: 'Write a 5-bullet executive summary covering scope, term and SLAs.',
- *     returnCitations: true,
- *   }))
- *   .return({
- *     summary:   out('summarizeContract', 'content.Text'),
- *     citations: out('summarizeContract', 'content.Citations'),
- *   })
- * ```
- *
- * @param inputs - The document (`attachment`), the question to answer (`prompt`),
- * and whether to return citations.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function summarize(inputs: SummarizeInputs): ActionSpec;
-/**
- * Add AI-generated columns to a CSV — the platform's **Batch transform** node,
- * `uipath.pattern.batch-transform` (service contract `ECS.BatchTransform`).
- *
- * @remarks
- * The output is a **file handle for the enriched CSV**, not the rows:
- * `{ ID, FullName, MimeType }` — the service writes a new
- * `batch-transform-<uuid>.csv` and hands back its attachment. Note `ID`, two
- * capitals: that is what the platform returns.
- *
- * Same dispatch story as {@link summarize} — dry-run fixture locally, a real
- * model call only on a platform run.
- *
- * @example
- * **Categorize each CSV row with two generated columns**
- * ```ts
- * flow('BatchTransformDemo')
- *   .input({ csvFile: types.file })
- *   .output({ result: types.file })
- *   .step('categorizeRows', batchTransform({
- *     attachment: out('start', 'csvFile'),
- *     prompt: 'Classify each row by category and write a one-line summary.',
- *     outputColumns: [
- *       { name: 'Category', description: 'One of: Utility, Software, Travel, Other' },
- *       { name: 'Summary',  description: 'Plain-English one-line summary of the row' },
- *     ],
- *   }))
- *   .return({ result: out('categorizeRows') })
- * ```
- *
- * @param inputs - The CSV (`attachment`), the instruction (`prompt`), and the
- * `outputColumns` to add to each row.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export declare function batchTransform(inputs: BatchTransformInputs): ActionSpec;
 /**
  * Extract fields from a document with a published IxP project — the platform's
  * **Extract** node (`uipath.ixp.*`, service contract `IXP.Extraction`).

package/dist/core/actions.js

@@ -88,21 +88,6 @@ export function builtinActionSpec(spec) {
 export function builtinTriggerSpec(spec) {
     return new BuiltinTrigger(spec);
 }
-/**
- * Declare an HTTP request action, explicitly choosing standalone or managed.
- *
- * @param inputs - The request: `url`, `method`, `body`, the response fields you
- * read back via `returns`, and the `managed` node choice.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function http(inputs) {
-    if (typeof inputs.managed !== 'boolean') {
-        throw new Error('http() requires managed: true or managed: false because they emit different platform nodes. '
-            + 'Use true for Managed HTTP Request/core.action.http.v2 or when non-2xx statuses must reach .onError(); '
-            + 'use false for the standalone core.action.http node.');
-    }
-    return builtinActionSpec({ kind: 'http', inputs });
-}
 /**
  * Declare a human task — a step that pauses for a person to read some values,
  * fill others in, and press one of the outcome buttons.
@@ -157,86 +142,6 @@ export function http(inputs) {
 export function hitl(inputs) {
     return builtinActionSpec({ kind: 'hitl', inputs });
 }
-/**
- * Summarize a document with citations — the platform's **Summarize** node.
- *
- * @remarks
- * **The node type is `uipath.pattern.deep-rag`.** The canvas calls it
- * *Summarize*, its properties panel is titled *Summarize Configuration*, and
- * the wire type stays `deep-rag` — it is the same node, under the name the
- * backend service contract uses (`ECS.DeepRag`). There is no
- * `uipath.pattern.summarize`. (A same-named inline-agent TOOL,
- * `uipath.agent.resource.tool.builtin.summarize`, is a different family.)
- *
- * The answer's fields are **PascalCase** — `content.Text`,
- * `content.Citations[].{Ordinal, PageNumber, Source, Reference}`. Lowercase
- * `content.text` resolves to nothing at run time.
- *
- * A local run cannot reach the service: it returns the baked
- * fixture shape, and only a real platform run (`uip maestro flow debug
- * --attachment <var>=<file>`) calls the model.
- *
- * @example
- * **Summarize an attached contract, with citations**
- * ```ts
- * flow('SummarizeDemo')
- *   .input({ documentFile: types.file })
- *   .output({ summary: types.string, citations: types.array })
- *   .step('summarizeContract', summarize({
- *     attachment: out('start', 'documentFile'),
- *     prompt: 'Write a 5-bullet executive summary covering scope, term and SLAs.',
- *     returnCitations: true,
- *   }))
- *   .return({
- *     summary:   out('summarizeContract', 'content.Text'),
- *     citations: out('summarizeContract', 'content.Citations'),
- *   })
- * ```
- *
- * @param inputs - The document (`attachment`), the question to answer (`prompt`),
- * and whether to return citations.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function summarize(inputs) {
-    return builtinActionSpec({ kind: 'summarize', inputs });
-}
-/**
- * Add AI-generated columns to a CSV — the platform's **Batch transform** node,
- * `uipath.pattern.batch-transform` (service contract `ECS.BatchTransform`).
- *
- * @remarks
- * The output is a **file handle for the enriched CSV**, not the rows:
- * `{ ID, FullName, MimeType }` — the service writes a new
- * `batch-transform-<uuid>.csv` and hands back its attachment. Note `ID`, two
- * capitals: that is what the platform returns.
- *
- * Same dispatch story as {@link summarize} — dry-run fixture locally, a real
- * model call only on a platform run.
- *
- * @example
- * **Categorize each CSV row with two generated columns**
- * ```ts
- * flow('BatchTransformDemo')
- *   .input({ csvFile: types.file })
- *   .output({ result: types.file })
- *   .step('categorizeRows', batchTransform({
- *     attachment: out('start', 'csvFile'),
- *     prompt: 'Classify each row by category and write a one-line summary.',
- *     outputColumns: [
- *       { name: 'Category', description: 'One of: Utility, Software, Travel, Other' },
- *       { name: 'Summary',  description: 'Plain-English one-line summary of the row' },
- *     ],
- *   }))
- *   .return({ result: out('categorizeRows') })
- * ```
- *
- * @param inputs - The CSV (`attachment`), the instruction (`prompt`), and the
- * `outputColumns` to add to each row.
- * @returns An action spec to pass to `.step(name, …)`.
- */
-export function batchTransform(inputs) {
-    return builtinActionSpec({ kind: 'batchTransform', inputs });
-}
 /**
  * Extract fields from a document with a published IxP project — the platform's
  * **Extract** node (`uipath.ixp.*`, service contract `IXP.Extraction`).

package/dist/core/expr.d.ts

@@ -196,7 +196,7 @@ export type ErrorEnvelopeField = 'code' | 'message' | 'detail' | 'category' | 's
  *
  * So the author writes one shape, `.error.<field>`, and `serialize` rewrites it
  * to `.output.<field>` for the one family that publishes it there
- * (`ERROR_ENVELOPE_VAR` in `serialize.ts`). Do not hand-write either prefix: which
+ * (a node type's `errorEnvelope`). Do not hand-write either prefix: which
  * one is right is not a property of the expression, it is a property of the node
  * the step happens to be, and only the builder knows that.
  *

package/dist/core/expr.js

@@ -209,7 +209,7 @@ export function ran(step) {
  *
  * So the author writes one shape, `.error.<field>`, and `serialize` rewrites it
  * to `.output.<field>` for the one family that publishes it there
- * (`ERROR_ENVELOPE_VAR` in `serialize.ts`). Do not hand-write either prefix: which
+ * (a node type's `errorEnvelope`). Do not hand-write either prefix: which
  * one is right is not a property of the expression, it is a property of the node
  * the step happens to be, and only the builder knows that.
  *
@@ -258,7 +258,7 @@ export function ran(step) {
  */
 export function err(step, field) {
     // ONE shape for every family. `serialize` rewrites the prefix for the families
-    // that publish the envelope elsewhere — see `ERROR_ENVELOPE_VAR`.
+    // that publish the envelope elsewhere — see `FlowNodeType.errorEnvelope`.
     return new Expr(`$vars.${step}.error${field ? '.' + field : ''}`);
 }
 /**

package/dist/core/nodes/node-type.d.ts

@@ -45,6 +45,13 @@ export interface OutputRead {
     /** The step whose expression contains the read. */
     reader: string;
 }
+/** A read of a node's output, split where a `reader` contract checks it. */
+export interface OutputPathRead extends OutputRead {
+    /** The first segment after the step (`output`, `error`, …); undefined for a read of the step itself. */
+    field: string | undefined;
+    /** The path after `field`, as the reference spells it (with its leading `.`); `''` when there is none. */
+    rest: string;
+}
 /**
  * How the artifact words a read of a `fields` output: the code prefix its read
  * diagnostics share (`<PREFIX>_READ_NOT_OUTPUT`, `_READ_WITHOUT_RETURNS`,
@@ -65,6 +72,11 @@ export interface FieldsRead {
  * states the fields a read may name — `undefined` when the author declared none,
  * which makes any field read its own mistake — and `read` keeps the wording of
  * the read rule it replaces, for the same reason. `open` admits any field.
+ *
+ * `reader` is for an output whose shape no field list states: an HTTP response is
+ * an envelope (`body`, `statusCode`, `headers`) whose `body` holds the author's
+ * `returns`. The type checks each read itself and reports through its family's
+ * catalog, with the codes it had before the port.
  */
 export type OutputContract = {
     readonly kind: 'none';
@@ -75,6 +87,9 @@ export type OutputContract = {
     readonly fields: Readonly<Record<string, TypeDesc>> | undefined;
     readonly open?: boolean;
     readonly read: FieldsRead;
+} | {
+    readonly kind: 'reader';
+    read(read: OutputPathRead, report: (code: string, message: string, suggestion?: string) => void): void;
 } | {
     readonly kind: 'opaque';
 };

package/dist/core/step-ports.js

@@ -1,14 +1,15 @@
 /**
- * The exits an action declares that the AUTHOR named — a human task's outcomes,
- * an HTTP call's response branches — and the port each one leaves on.
+ * The exits an action declares that the AUTHOR named — a human task's outcomes —
+ * and the port each one leaves on. A registered node type declares its own
+ * (`FlowNodeType.exits`: an HTTP call's response branches); `stepExits` in
+ * flow-step-exits.ts asks it first and falls back here.
  *
  * This is what `.stepSwitch()` routes over, and the reason it exists as a table
- * rather than as two more `if (spec.kind === …)` arms: `serialize` has to turn
+ * rather than as more `if (spec.kind === …)` arms: `serialize` has to turn
  * an arm's `value` into a port, `check` has to say which values are legal and
  * which were left out, and `decompile` has to turn a port back into a value.
- * Those three read the same list here instead of each carrying their own copy
- * of "how a human task names its ports" and "how an HTTP branch names its
- * ports".
+ * Those three read the same list instead of each carrying their own copy of
+ * "how a human task names its ports".
  *
  * `undefined` means the family has no author-declared fan-out at all, which is
  * what makes `.stepSwitch()` on it an error rather than a no-op.
@@ -68,23 +69,6 @@ export function declaredExits(spec, pinnedVersion) {
             ...(e.endsProcess ? { endsProcess: true } : {}),
         }));
     }
-    if (kind === 'http') {
-        const branches = (spec?.inputs?.branches
-            ?? []);
-        if (branches.length === 0) {
-            return {
-                reason: 'it declares no response branches',
-                suggestion: `branches: [{ name: 'rateLimited', condition: … }]`,
-            };
-        }
-        // The fall-through is an exit like any other here — it is what `.switch()`
-        // spells as its default arm, and leaving it out is the same omission as
-        // leaving out a branch.
-        return [
-            ...branches.map((b) => ({ value: String(b?.name ?? ''), port: `branch-${b?.name ?? ''}` })),
-            { value: 'default', port: 'default', isDefault: true },
-        ];
-    }
     return {
         reason: `a ${kind ?? 'custom'} step declares no author-named exits`,
         suggestion: 'Use .step(); route failures with .onError().',

package/dist/core/typed-raw-node.js

@@ -21,8 +21,6 @@ import { ownEntry } from './own-entry.js';
  * themselves (the Data Fabric verbs, since Phase 3).
  */
 export const TYPED_FACTORIES = {
-    'core.action.http': { factory: 'http({ managed: false })' },
-    'core.action.http.v2': { factory: 'http({ managed: true })' },
     'core.control.end': { factory: '.return()' },
     'core.logic.decision': { factory: '.branch()' },
     'core.logic.dowhile': { factory: '.doWhile(name, condition, body, { limit, breakEnabled })' },
@@ -47,8 +45,6 @@ export const TYPED_FACTORIES = {
         factory: "hitl({ variant: 'document-validation' })",
     },
     'uipath.human-in-the-loop.quick-form': { factory: "hitl({ variant: 'quick-form' })" },
-    'uipath.pattern.batch-transform': { factory: 'batchTransform()' },
-    'uipath.pattern.deep-rag': { factory: 'summarize()' },
 };
 /**
  * A reminder, as a `warning`, that a `rawNode` stands in for a typed factory,