@uipath/maestro-sdk 0.9.1 → 1.0.2

package/dist/src/client.d.ts

@@ -1,3 +1,5 @@
 import type { PimsApiConfig, PimsRequestOptions } from "./types";
 export declare function pimsGet<T>(config: PimsApiConfig, path: string, options?: PimsRequestOptions): Promise<T>;
 export declare function pimsPost<T>(config: PimsApiConfig, path: string, body?: unknown, options?: PimsRequestOptions): Promise<T>;
+export declare function pimsPut<T>(config: PimsApiConfig, path: string, body?: unknown, options?: PimsRequestOptions): Promise<T>;
+export declare function pimsPatch<T>(config: PimsApiConfig, path: string, body?: unknown, options?: PimsRequestOptions): Promise<T>;

package/dist/src/debug-http-client.d.ts

@@ -4,27 +4,125 @@
  * Used by flow-tool, case-tool, and maestro-tool.
  */
 import type { OrchestratorApiConfig } from "./debug-types";
+/** Logical service the helper is talking to. Used by callers / formatters
+ *  to render the failing endpoint with the right URL prefix. */
+export type DebugApiService = "orchestrator" | "pims" | "studio-web";
+/** Structured payload carried by a {@link MaestroHttpError}. Every field
+ *  except {@link stage} is always populated; {@link stage} is filled in by the
+ *  caller via the optional `stage` parameter on each helper. */
+export interface MaestroHttpErrorDetails {
+    service: DebugApiService;
+    method: string;
+    /** Endpoint path relative to the service root (e.g. `/api/v1/debug-instances`). */
+    endpoint: string;
+    /** Fully resolved URL the helper hit. */
+    url: string;
+    httpStatus: number;
+    statusText: string;
+    /** Raw response body — kept verbatim for diagnostics. May be empty/null
+     *  on Studio Web errors. */
+    body: string;
+    /** Pipeline stage label provided by the caller (e.g. "create-debug-instance").
+     *  Optional because not every helper has a clearly labelled stage. */
+    stage?: string;
+    /** Parsed `errorCode` from a JSON body matching `{errorCode}`. The PIMS /
+     *  Maestro convention is to serialise codes as numbers; we keep it as a
+     *  string here so the field shape lines up with {@link import("@uipath/common").ErrorContext.errorCode}. */
+    parsedErrorCode?: string;
+    /** Parsed top-level `message` from a JSON body matching `{message}`. */
+    parsedErrorMessage?: string;
+    /** Parsed `traceId` (Application Insights / W3C trace-context). */
+    parsedTraceId?: string;
+    /** Parsed `requestId` when the backend sends one separately from `traceId`. */
+    parsedRequestId?: string;
+}
 /**
- * Make a GET request to Orchestrator API
+ * Try to parse the standard UiPath backend error body
+ * `{ "message": "...", "errorCode": <number|string>, "traceId": "...", "requestId": "..." }`.
+ *
+ * Returns the recognised fields (all optional). Never throws — invalid JSON
+ * or unexpected shapes produce an empty object.
  */
-export declare function orchestratorGet<T>(config: OrchestratorApiConfig, path: string): Promise<T>;
+export declare function parseBackendErrorBody(body: string): {
+    message?: string;
+    errorCode?: string;
+    traceId?: string;
+    requestId?: string;
+};
 /**
- * Make a POST request to Orchestrator API
+ * Structured error thrown by every HTTP helper in this module. Carries the
+ * full request/response context (stage, method, endpoint, URL, status, body,
+ * parsed backend error fields) so callers can populate
+ * {@link import("@uipath/common").ErrorContext} without parsing free text.
+ *
+ * The `message` is human-readable and includes the stage when available,
+ * matching the existing CLI failure-message conventions.
  */
-export declare function orchestratorPost<T>(config: OrchestratorApiConfig, path: string, body: unknown): Promise<T>;
+export declare class MaestroHttpError extends Error {
+    readonly service: DebugApiService;
+    readonly method: string;
+    readonly endpoint: string;
+    readonly url: string;
+    readonly httpStatus: number;
+    readonly statusText: string;
+    readonly body: string;
+    readonly stage?: string;
+    readonly parsedErrorCode?: string;
+    readonly parsedErrorMessage?: string;
+    readonly parsedTraceId?: string;
+    readonly parsedRequestId?: string;
+    constructor(details: MaestroHttpErrorDetails);
+    /** Build the human-readable message. Includes the stage when set, so a
+     *  consumer that only sees `error.message` still gets a useful breadcrumb.
+     *
+     *  IMPORTANT: the message intentionally never embeds the raw response
+     *  body — only the parsed `message` field. Future callers that follow the
+     *  standard pattern `OutputFormatter.error({ Message: err.message })`
+     *  must not leak unstructured backend payloads to users. The full raw
+     *  body is on `.body` for diagnostics; structured fields go to
+     *  `FailureOutput.Context`. */
+    private static formatMessage;
+}
 /**
- * Make a GET request to PIMS API (debug path, not /api/v1)
+ * Make a GET request to Orchestrator API.
+ * @param stage Optional pipeline stage label (e.g. "get-personal-folder").
+ *              Surfaced on {@link MaestroHttpError.stage} for structured
+ *              error reporting downstream.
  */
-export declare function debugPimsGet<T>(config: OrchestratorApiConfig, path: string): Promise<T>;
+export declare function orchestratorGet<T>(config: OrchestratorApiConfig, path: string, stage?: string): Promise<T>;
 /**
- * Make a POST request to PIMS API (debug path, not /api/v1)
+ * Make a POST request to Orchestrator API.
+ * @param stage Optional pipeline stage label (e.g. "begin-debug-session").
  */
-export declare function debugPimsPost<T>(config: OrchestratorApiConfig, path: string, body: unknown): Promise<T>;
+export declare function orchestratorPost<T>(config: OrchestratorApiConfig, path: string, body: unknown, stage?: string): Promise<T>;
 /**
- * Make a POST request to Studio Web backend API
+ * Make a GET request to PIMS API (debug path, not /api/v1).
+ * @param stage Optional pipeline stage label (e.g. "poll-instance-status",
+ *              "fetch-output-variables").
  */
-export declare function studioWebPost<T>(config: OrchestratorApiConfig, organizationName: string, path: string, body: FormData | unknown, extraHeaders?: Record<string, string>): Promise<T>;
+export declare function debugPimsGet<T>(config: OrchestratorApiConfig, path: string, stage?: string): Promise<T>;
 /**
- * Make a DELETE request to Studio Web backend API
+ * Make a POST request to PIMS API (debug path, not /api/v1).
+ * @param stage Optional pipeline stage label (e.g. "create-debug-instance").
  */
-export declare function studioWebDelete(config: OrchestratorApiConfig, organizationName: string, path: string): Promise<void>;
+export declare function debugPimsPost<T>(config: OrchestratorApiConfig, path: string, body: unknown, stage?: string): Promise<T>;
+/**
+ * Make a PUT request to PIMS API (debug path, not /api/v1).
+ * @param stage Optional pipeline stage label.
+ */
+export declare function debugPimsPut<T>(config: OrchestratorApiConfig, path: string, body: unknown, stage?: string): Promise<T>;
+/**
+ * Make a PATCH request to PIMS API (debug path, not /api/v1).
+ * @param stage Optional pipeline stage label.
+ */
+export declare function debugPimsPatch<T>(config: OrchestratorApiConfig, path: string, body: unknown, stage?: string): Promise<T>;
+/**
+ * Make a POST request to Studio Web backend API.
+ * @param stage Optional pipeline stage label (e.g. "register-connection-resource").
+ */
+export declare function studioWebPost<T>(config: OrchestratorApiConfig, organizationName: string, path: string, body: FormData | unknown, extraHeaders?: Record<string, string>, stage?: string): Promise<T>;
+/**
+ * Make a DELETE request to Studio Web backend API.
+ * @param stage Optional pipeline stage label.
+ */
+export declare function studioWebDelete(config: OrchestratorApiConfig, organizationName: string, path: string, stage?: string): Promise<void>;

package/dist/src/debug-service.d.ts

@@ -3,7 +3,30 @@
  * Provides common methods used by flow-tool, case-tool, and maestro-tool.
  */
 import type { IFileSystem } from "@uipath/filesystem";
-import type { BeginSessionResponse, DebugCallbacks, DebugInstanceResponse, DebugInstanceStatusResponse, DebugResult, OrchestratorApiConfig } from "./debug-types";
+import type { BeginSessionResponse, DebugCallbacks, DebugInstanceResponse, DebugInstanceStatusResponse, DebugResult, InlineAgentDescriptor, OrchestratorApiConfig } from "./debug-types";
+/**
+ * Thrown by {@link injectInlineAgentProcessEntries} when `FpsProperties`
+ * is not valid JSON and inline agents need to be injected.
+ */
+export declare class FpsPropertiesInjectionError extends Error {
+    readonly fpsProperties: string;
+    readonly agentCount: number;
+    readonly cause: unknown;
+    constructor(fpsProperties: string, agentCount: number, cause?: unknown);
+}
+/**
+ * Append inline-agent process entries to the (doubly-encoded)
+ * `FpsProperties.debug.master.processes` array and return the re-encoded
+ * value. When no agents are supplied, the input is returned unchanged.
+ *
+ * Mirror of `flow-workbench`'s `injectInlineAgentProcessEntries` so
+ * `uip maestro flow debug` provisions inline agents the same way the
+ * Studio Web / VS Code debug paths do.
+ *
+ * @throws {FpsPropertiesInjectionError} when agents are supplied and
+ *   `fpsProperties` cannot be parsed.
+ */
+export declare function injectInlineAgentProcessEntries(fpsProperties: string | undefined, inlineAgents?: InlineAgentDescriptor[]): string | undefined;
 /**
  * Extract the first bpmn:startEvent id from BPMN XML.
  * Falls back to "start" if no start event is found.
@@ -28,15 +51,34 @@ export interface PersonalFolderInfo {
  * Returns key, id, display name, fully qualified name, and parent key.
  */
 export declare function getPersonalFolderInfo(config: OrchestratorApiConfig): Promise<PersonalFolderInfo>;
+export interface BeginDebugSessionOptions {
+    /** Inline agents to register with the debug session via FpsProperties. */
+    inlineAgents?: InlineAgentDescriptor[];
+    /**
+     * Pre-existing `FpsProperties` JSON string. Inline agents (when
+     * supplied) are appended into `debug.master.processes` on top of this.
+     */
+    fpsProperties?: string;
+}
 /**
  * Begin a debug session in Orchestrator.
+ *
+ * When `options.inlineAgents` is non-empty, each agent is encoded into
+ * `FpsProperties.debug.master.processes` so the runtime can resolve the
+ * `Orchestrator.StartInlineAgentJob` activity that fires for each agent
+ * node — without it Orchestrator returns 404 "the job's associated
+ * process could not be found".
  */
-export declare function beginDebugSession(config: OrchestratorApiConfig, inputArguments?: string): Promise<BeginSessionResponse>;
+export declare function beginDebugSession(config: OrchestratorApiConfig, inputArguments?: string, options?: BeginDebugSessionOptions): Promise<BeginSessionResponse>;
+export declare const DEBUG_MODE_MAP: Record<string, number>;
+export declare const SIMULATION_MODE_MAP: Record<string, number>;
 /**
  * Create a debug instance in PIMS.
  * @param processType - "Flow" for flow-tool, "case" for case-tool, "processOrchestration" for maestro-tool
+ * @param debugMode - "Default" (pause at breakpoints), "StepByStep", "SingleStep", or "None"
+ * @param simulationMode - "None", "All", or "Selective"
  */
-export declare function createDebugInstance(config: OrchestratorApiConfig, jobKey: string, solutionId: string, studioWebProjectId: string, entryPoint: string, processType?: string): Promise<DebugInstanceResponse>;
+export declare function createDebugInstance(config: OrchestratorApiConfig, jobKey: string, solutionId: string, studioWebProjectId: string, entryPoint: string, processType?: string, debugMode?: string, simulationMode?: string): Promise<DebugInstanceResponse>;
 /**
  * Poll PIMS debug instance element-executions until terminal status.
  */
@@ -74,6 +116,12 @@ export interface UploadAndDebugParams {
         key: string;
         id: number;
     };
+    /**
+     * Inline agents to register with the debug session. Forwarded to
+     * BeginSession via FpsProperties so the runtime can resolve each
+     * agent's `Orchestrator.StartInlineAgentJob` lookup.
+     */
+    inlineAgents?: InlineAgentDescriptor[];
 }
 /**
  * Shared upload-and-debug lifecycle used by flow-tool, maestro-tool, and case-tool.

package/dist/src/debug-types.d.ts

@@ -24,6 +24,32 @@ export interface BeginSessionResponse {
     vncTunnelUri: string | null;
     jobKey: string;
 }
+/**
+ * Describes an inline (in-flow) agent that the debug session must
+ * provision as a child Orchestrator process. Studio Web's debug path
+ * encodes one entry per agent into `FpsProperties.debug.master.processes`
+ * so the runtime's `Orchestrator.StartInlineAgentJob` activity can
+ * resolve the process by `executorInfo.projectId`.
+ *
+ * Without these entries, the runtime returns 404 "the job's associated
+ * process could not be found" the first time the BPMN tries to start the
+ * agent — which is what `uip maestro flow debug` hit before this fix.
+ */
+export interface InlineAgentDescriptor {
+    /** Display name of the agent — surfaces in Orchestrator logs/UX. */
+    name: string;
+    /** The agent's `projectId` UUID (folder name on disk). */
+    agentProjectId: string;
+    /** True for `uipath.agent.conversational`, false for autonomous. */
+    isConversational: boolean;
+    /**
+     * Path to the agent's `agent.json` inside the package, relative to the
+     * package content root (i.e. `<projectId>/agent.json`). Matches the
+     * shape Studio Web sends — no `content/` prefix here; the runtime
+     * resolves the path against the deployed package.
+     */
+    entryPointPath: string;
+}
 export interface ElementExecution {
     elementId: string;
     elementType?: string;
@@ -36,6 +62,7 @@ export interface DebugResult {
     jobKey: string;
     instanceId: string;
     runId: string;
+    folderKey?: string;
     finalStatus: string;
     elementExecutions: ElementExecution[];
     solutionId?: string;
@@ -90,3 +117,71 @@ export interface DebugInstanceStatusResponse {
         }>;
     }>;
 }
+export interface Breakpoint {
+    activityId: string;
+}
+export interface BreakpointUpdateRequest {
+    breakpoints: Breakpoint[];
+}
+export interface ContinueOnBreakpointRequest {
+    nextStep: boolean;
+}
+export interface PatchElementInputs {
+    elementId: string;
+    inputs: unknown;
+    elementRunId?: string;
+}
+export interface PatchVariablesRequest {
+    globals?: unknown;
+    elements: PatchElementInputs[];
+}
+export interface DebugIncidentResponse {
+    id: string;
+    tenantId: string;
+    organizationId: string;
+    instanceId: string;
+    runId: string;
+    elementId: string | null;
+    elementRunId: string | null;
+    folderKey: string;
+    processKey: string | null;
+    packageVersion: string | null;
+    incidentId: string;
+    incidentStatus: string;
+    incidentType: string | null;
+    errorCode: string | null;
+    errorMessage: string;
+    errorTimeUtc: string;
+    errorDetails: string | null;
+    comment: string | null;
+    userUpdated: string | null;
+    debugMode: string | null;
+    incidentUpdateTimeUtc: string | null;
+    traceId: string | null;
+    dependentFaultCode: string | null;
+    incidentSeverity: string | null;
+    aiSummary: string | null;
+    aiRecommendations: string[] | null;
+    processType: string | null;
+}
+export interface DebugGetVariablesResponse {
+    elements: Array<{
+        elementId: string;
+        elementRunId: string;
+        isMarker: boolean;
+        inputs: Record<string, unknown>;
+        inputDefinitions: Record<string, unknown>;
+        outputs: Record<string, unknown>;
+    }>;
+    globals: Record<string, unknown>;
+    instanceId: string;
+    workflowId: string;
+    parentElementId: string | null;
+}
+export interface DebugGetAllVariablesResponse {
+    variables: DebugGetVariablesResponse[];
+}
+export interface DebugInstanceStatusResult {
+    instanceId: string;
+    status: string;
+}

package/dist/src/flags/manifest-flags.d.ts

@@ -1,4 +1,6 @@
 /** flow-core feature-flag constants — each gates a node category in ManifestClient. */
 export declare const FLAG_CONNECTOR_NODES = "canvas.mfe.dap-component";
+export declare const FLAG_EXTRACT_DOCUMENT = "canvas.nodes.extract-document";
+export declare const FLAG_HITL = "canvas.nodes.hitl";
 /** Returns a `getFeatureFlag` callback that enables the given flags. */
 export declare function buildFeatureFlagResolver(flags: readonly string[]): (flag: string) => boolean;

package/dist/src/index.d.ts

@@ -1,23 +1,30 @@
-export { pimsGet, pimsPost } from "./client";
+export { pimsGet, pimsPatch, pimsPost, pimsPut } from "./client";
 export { createPimsConfig } from "./client-factory";
-export { debugPimsGet, debugPimsPost, orchestratorGet, orchestratorPost, studioWebDelete, studioWebPost, } from "./debug-http-client";
-export type { PersonalFolderInfo, UploadAndDebugParams } from "./debug-service";
-export { beginDebugSession, createDebugInstance, extractStartEventId, getPersonalFolderInfo, getPersonalFolderKey, patchConnectionOverwrites, pollDebugInstanceStatus, uploadAndDebugSolution, } from "./debug-service";
-export type { BeginSessionResponse, DebugCallbacks, DebugInstanceResponse, DebugInstanceStatusResponse, DebugResult, DebugVariablesResponse, ElementExecution, OrchestratorApiConfig, StudioWebDebugConfig, } from "./debug-types";
-export { BPMN_SPEC } from "./manifest/bpmn-spec";
+export type { DebugApiService, MaestroHttpErrorDetails, } from "./debug-http-client";
+export { debugPimsGet, debugPimsPatch, debugPimsPost, debugPimsPut, MaestroHttpError, orchestratorGet, orchestratorPost, parseBackendErrorBody, studioWebDelete, studioWebPost, } from "./debug-http-client";
+export type { BeginDebugSessionOptions, PersonalFolderInfo, UploadAndDebugParams, } from "./debug-service";
+export { beginDebugSession, createDebugInstance, extractStartEventId, FpsPropertiesInjectionError, getPersonalFolderInfo, getPersonalFolderKey, injectInlineAgentProcessEntries, patchConnectionOverwrites, pollDebugInstanceStatus, uploadAndDebugSolution, } from "./debug-service";
+export type { BeginSessionResponse, BreakpointUpdateRequest, ContinueOnBreakpointRequest, DebugCallbacks, DebugGetAllVariablesResponse, DebugGetVariablesResponse, DebugIncidentResponse, DebugInstanceResponse, DebugInstanceStatusResponse, DebugInstanceStatusResult, DebugResult, DebugVariablesResponse, ElementExecution, InlineAgentDescriptor, OrchestratorApiConfig, PatchVariablesRequest, StudioWebDebugConfig, } from "./debug-types";
+export { parseJsonInputOrFile, readJsonFile, resolveJsonInput, } from "./json-input";
+export { BPMN_SPEC, SUPPORTED_UIPATH_EXTENSION_TAG_NAMES, SUPPORTED_UIPATH_EXTENSION_TAGS, } from "./manifest/bpmn-spec";
 export type { BpmnExtensionType, DiscoveredConnector, DiscoveredProcess, MaestroRegistry, RegistryMetadata, } from "./manifest/types";
 export { buildQueryString } from "./query-string";
 export type { CompactField, ConnectorInfo, ConnectorMethodInfo, ContextEntry, FieldReference, FilterCondition, FilterField, FilterOperator, ISField, ISFieldMethod, ISMetadata, ISMetadataParam, ParsedFilters, SyncMetadata, TriggerField, TriggerFieldEvent, TriggerObjectMetadata, } from "./registry/index.js";
-export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, enrichConnectorNode, extractMultipartParameters, extractTriggerFilterFields, FilterParseError, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorTriggerMetadata, filterNodes, getConnectorConfiguration, getConnectorInfo, getNode, getNodeEnriched, hashContent, isConnectorNode, isConnectorTriggerNode, listNodes, loadIndexMetadata, loadNodeIndex, MANAGED_HTTP_CONNECTOR_KEY, parseFilterString, pullNodes, pullRemoteNodes, registerRegistryCommand, resolveNodeStorageDir, saveIndexMetadata, saveNodeIndex, searchNodes, searchNodesWithFilters, searchWithFilters, } from "./registry/index.js";
+export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, enrichConnectorNode, extractActivityFilterFields, extractMultipartParameters, extractTriggerEventParameters, extractTriggerFilterFields, FilterParseError, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorTriggerMetadata, filterNodes, getConnectorConfiguration, getConnectorInfo, getNode, getNodeEnriched, hashContent, isConnectorNode, isConnectorTriggerNode, listNodes, loadIndexMetadata, loadNodeIndex, MANAGED_HTTP_CONNECTOR_KEY, parseFilterString, pullNodes, pullRemoteNodes, registerRegistryCommand, resolveNodeStorageDir, saveIndexMetadata, saveNodeIndex, searchNodes, searchNodesWithFilters, searchWithFilters, } from "./registry/index.js";
 export { getEnrichedActivityMetadata, getExtensionType, getRegistry, pullRegistry, searchRegistry, } from "./registry/registry-service";
 export { CACHE_EXPIRATION_MS, loadRegistry, loadRegistryMetadata, saveRegistry, } from "./registry/storage";
+export type { DebugInstanceCommandsConfig } from "./shared-commands/debug-instances";
+export { registerSharedDebugInstanceCommands } from "./shared-commands/debug-instances";
 export type { IncidentCommandsConfig } from "./shared-commands/incidents";
 export { registerSharedIncidentCommands } from "./shared-commands/incidents";
 export type { InstanceCommandsConfig } from "./shared-commands/instances";
 export { registerSharedInstanceCommands } from "./shared-commands/instances";
+export type { ProcessCommandsConfig } from "./shared-commands/process";
+export { registerSharedProcessCommands } from "./shared-commands/process";
 export type { ProcessesCommandsConfig } from "./shared-commands/processes";
 export { registerSharedProcessesCommands } from "./shared-commands/processes";
 export type { TraceEvent } from "./shared-utils";
 export { formatTraceLine, formatTraceStatus, readStdin, VALID_PACKAGE_NAME_REGEX, VALID_PROJECT_NAME_REGEX, } from "./shared-utils";
-export type { ElementExecutionApi, ElementMetaData, GetInstanceElementExecutionsResponse, GlobalVariableMetaData, GoToCursorsResponse, GoToTransition, MaestroProcessSummary, PimsApiConfig, PimsRequestOptions, ProcessIncidentGetAllResponse, ProcessIncidentGetResponse, ProcessInstance, ProcessInstanceGetVariablesResponse, ProcessInstanceOperationResponse, ProcessInstanceRun, } from "./types";
+export type { BpmnElementTags, BpmnOutputTags, BpmnProcessVariableTags, ElementExecutionApi, ElementMetaData, ErrorCodeItem, ErrorCodesResponse, GetAllVariablesResponse, GetGlobalVariablesResponse, GetInstanceElementExecutionsResponse, GlobalVariableMetaData, GoToCursorsResponse, GoToTransition, MaestroMessageSendRequest, MaestroMessageSendResponse, MaestroProcessSummary, PimsApiConfig, PimsRequestOptions, ProcessIncidentGetAllResponse, ProcessIncidentGetResponse, ProcessInstance, ProcessInstanceGetVariablesResponse, ProcessInstanceOperationResponse, ProcessInstanceRun, ProcessSettings, } from "./types";
+export { withDebugPimsCall } from "./with-debug-pims-call";
 export { withPimsCall } from "./with-pims-call";

package/dist/src/json-input.d.ts

@@ -0,0 +1,15 @@
+export declare function readJsonFile(filePath: string): Promise<unknown>;
+export declare function parseJsonInputOrFile(inputSource: string): Promise<unknown>;
+/**
+ * Resolves a JSON payload from the first available source:
+ *   1. `inline` — raw JSON string or `@file` reference (e.g. the value of a
+ *      `--inputs` flag).
+ *   2. stdin — only consulted when `allowStdin` is true and `inline` is absent.
+ *
+ * Returns `undefined` when no source provides any data, so the caller can
+ * decide whether the missing payload is an error or a default-empty case.
+ */
+export declare function resolveJsonInput(opts: {
+    inline?: string;
+    allowStdin?: boolean;
+}): Promise<unknown | undefined>;

package/dist/src/manifest/bpmn-spec.d.ts

@@ -20,3 +20,12 @@ export interface BpmnSpec {
  * serialization rules extracted from the frontend codebase.
  */
 export declare const BPMN_SPEC: BpmnSpec;
+/**
+ * UiPath BPMN extension element names supported by Maestro exports.
+ *
+ * `BPMN_SPEC.extensionTypes` covers executable payload containers
+ * (`activity`, `event`, `mapping`). Maestro BPMN files also carry structural
+ * metadata such as variables, bindings, and entry point ids.
+ */
+export declare const SUPPORTED_UIPATH_EXTENSION_TAG_NAMES: readonly string[];
+export declare const SUPPORTED_UIPATH_EXTENSION_TAGS: readonly string[];

package/dist/src/registry/command.d.ts

@@ -4,7 +4,7 @@ import type { Command } from "commander";
  *
  * The registry is shared across UiPath workflow surfaces (flow, maestro, …).
  * Each tool exposes the same actions under its own command prefix, e.g.
- * `uip flow registry pull` or `uip maestro registry pull`.
+ * `uip maestro flow registry pull` or `uip maestro registry pull`.
  *
  * @param program       Parent commander program/command to attach to
  * @param commandPrefix Tool prefix (e.g. "maestro flow" or "maestro bpmn") used in help text

package/dist/src/registry/index.d.ts

@@ -1,8 +1,8 @@
-export { buildFeatureFlagResolver, FLAG_CONNECTOR_NODES, } from "../flags/manifest-flags.js";
+export { buildFeatureFlagResolver, FLAG_CONNECTOR_NODES, FLAG_EXTRACT_DOCUMENT, } from "../flags/manifest-flags.js";
 export { registerRegistryCommand } from "./command.js";
 export { filterNodes, searchWithFilters, } from "./filter-engine.js";
 export { FilterParseError, parseFilterString } from "./filter-parser.js";
-export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, enrichConnectorNode, extractMultipartParameters, extractTriggerFilterFields, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorTriggerMetadata, getConnectorConfiguration, getConnectorInfo, isConnectorNode, isConnectorTriggerNode, MANAGED_HTTP_CONNECTOR_KEY, } from "./integration-service-fetcher.js";
+export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, enrichConnectorNode, extractActivityFilterFields, extractMultipartParameters, extractTriggerEventParameters, extractTriggerFilterFields, fetchConnectionInfo, fetchConnectorMetadata, fetchConnectorTriggerMetadata, getConnectorConfiguration, getConnectorInfo, isConnectorNode, isConnectorTriggerNode, MANAGED_HTTP_CONNECTOR_KEY, } from "./integration-service-fetcher.js";
 export type { CompactField, ConnectorInfo, ConnectorMethodInfo, ContextEntry, FieldReference, ISField, ISFieldMethod, ISMetadata, ISMetadataParam, TriggerField, TriggerFieldEvent, TriggerObjectMetadata, } from "./integration-service-metadata.types";
 export { hashContent, loadIndexMetadata, loadNodeIndex, resolveNodeStorageDir, type SyncMetadata, saveIndexMetadata, saveNodeIndex, } from "./node-storage.js";
 export { getNode, getNodeEnriched, listNodes, pullNodes, pullRemoteNodes, searchNodes, searchNodesWithFilters, } from "./node-sync-service.js";

package/dist/src/registry/integration-service-fetcher.d.ts

@@ -3,7 +3,24 @@ import type { CompactField, ConnectorConfiguration, ConnectorInfo, ISMetadata, T
 export { buildActivityEssentialConfiguration, buildInputMetadata, buildManagedHttpEssentialConfiguration, buildTriggerEssentialConfiguration, extractMultipartParameters, MANAGED_HTTP_CONNECTOR_KEY, } from "@uipath/integrationservice-sdk";
 export declare function isConnectorNode(node: NodeManifest): boolean;
 export declare function isConnectorTriggerNode(node: NodeManifest): boolean;
+export declare function extractTriggerEventParameters(metadata: TriggerObjectMetadata, operationName: string): CompactField[];
 export declare function extractTriggerFilterFields(metadata: TriggerObjectMetadata): CompactField[];
+/**
+ * Extract filterable activity fields for a List/query operation.
+ *
+ * Contract (per the IS metadata schema):
+ *
+ * - A field is filterable when `searchable === true`. Type is irrelevant for
+ *   the filter check — connectors flag the fields they accept in CEQL
+ *   queries explicitly, and that flag is the source of truth.
+ * - `searchableOperators` (when present) lists the CEQL operators the
+ *   connector permits for the field. We surface it on the compact output so
+ *   callers can validate operator choices upstream.
+ * - `searchableNames` (when present) lists alternative identifiers the
+ *   connector accepts for the field in CEQL. The filter compiler emits
+ *   `searchableNames[0]` instead of `name` when set.
+ */
+export declare function extractActivityFilterFields(metadata: ISMetadata, _method: string): CompactField[];
 export declare function fetchConnectorTriggerMetadata(connectorKey: string, operationName: string, objectName: string, connectionId: string): Promise<TriggerObjectMetadata>;
 export declare function getConnectorConfiguration(node: NodeManifest): ConnectorConfiguration | null;
 export declare function getConnectorInfo(node: NodeManifest): ConnectorInfo | null;
@@ -20,6 +37,10 @@ export interface ConnectionInfo {
     connectorName: string;
     connectorVersion: string | null;
     pollingInterval: number | null;
+    byoaConnection: boolean;
+    elementInstanceId: number | null;
+    /** Folder the connection belongs to. Null for tenant-scoped connections. */
+    folderKey: string | null;
 }
 /**
  * Fetch connection details by ID from Integration Service.

package/dist/src/registry/integration-service-metadata.types.d.ts

@@ -8,11 +8,17 @@ export type CompactField = {
     name: string;
     displayName: string;
     type: string;
+    /** Alias of `type`; emitted for parity with case-tool FieldSpec and downstream skills that document field schemas as `{ name, dataType, ... }`. */
+    dataType: string;
     required: boolean;
     description?: string;
     responseOnly?: true;
     enum?: unknown[];
     reference?: FieldReference;
+    /** CEQL operators the connector permits for this field (when searchable). */
+    searchableOperators?: string[];
+    /** Connector-side aliases for this field in CEQL queries. */
+    searchableNames?: string[];
 };
 export type ConnectorConfiguration = {
     connectorKey: string;

package/dist/src/shared-commands/debug-instances.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+export interface DebugInstanceCommandsConfig {
+    /** Label used in command descriptions, e.g. "Maestro", "Flow", "Case" */
+    toolLabel: string;
+}
+export declare const registerSharedDebugInstanceCommands: (program: Command, config: DebugInstanceCommandsConfig) => void;

package/dist/src/shared-commands/process.d.ts

@@ -0,0 +1,6 @@
+import type { Command } from "commander";
+export interface ProcessCommandsConfig {
+    /** Label used in command descriptions, e.g. "Flow", "Maestro", "Case" */
+    toolLabel: string;
+}
+export declare const registerSharedProcessCommands: (processCmd: Command, config: ProcessCommandsConfig) => void;

package/dist/src/types.d.ts

@@ -57,6 +57,15 @@ export interface ProcessInstanceGetVariablesResponse {
     globalVariables: GlobalVariableMetaData[];
     elements: ElementMetaData[];
 }
+export interface GetAllVariablesResponse {
+    variables: ProcessInstanceGetVariablesResponse[];
+}
+export interface GetGlobalVariablesResponse {
+    instanceId: string;
+    globals: Record<string, unknown>;
+    count: number;
+    retrievedAt: string;
+}
 export interface ProcessIncidentGetResponse {
     incidentId: string;
     instanceId: string;
@@ -93,6 +102,41 @@ export interface GoToTransition {
 export interface GoToCursorsResponse {
     elementIds: string[];
 }
+export interface ProcessSettings {
+    variableTags: BpmnProcessVariableTags;
+}
+export interface BpmnProcessVariableTags {
+    elements: Record<string, BpmnElementTags>;
+    sourcePackageVersion: string;
+    lastUpdateTimeUtc: string;
+}
+export interface BpmnElementTags {
+    outputs: BpmnOutputTags[];
+}
+export interface BpmnOutputTags {
+    tags: string[];
+    name: string;
+    extractPath: string;
+    label: string;
+    extractedValueType: string;
+}
+export interface MaestroMessageSendRequest {
+    name: string;
+    reference: string;
+    itemData: Record<string, unknown>;
+    ttl?: string;
+}
+export interface MaestroMessageSendResponse {
+    id: string;
+    jobId: string;
+}
+export interface ErrorCodeItem {
+    errorCode: string;
+    errorMessage: string;
+}
+export interface ErrorCodesResponse {
+    errorCodes: ErrorCodeItem[];
+}
 export interface ElementExecutionApi {
     completedTimeUtc: string | null;
     elementId: string;

package/dist/src/with-debug-pims-call.d.ts

@@ -0,0 +1,3 @@
+import type { OrchestratorApiConfig } from "./debug-types";
+export declare function createDebugPimsConfig(): Promise<OrchestratorApiConfig>;
+export declare function withDebugPimsCall<T>(fn: (config: OrchestratorApiConfig) => Promise<T>, errorMessage: string): Promise<T | undefined>;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@uipath/maestro-sdk",
-    "version": "0.9.1",
+    "version": "1.0.2",
     "description": "SDK for the UiPath Maestro (PIMS) API — process instance management.",
     "repository": {
         "type": "git",
@@ -23,27 +23,35 @@
         ".": {
             "types": "./dist/src/index.d.ts",
             "default": "./dist/index.js"
+        },
+        "./manifest/bpmn-spec": {
+            "types": "./dist/src/manifest/bpmn-spec.d.ts",
+            "import": "./dist/manifest/bpmn-spec.js",
+            "default": "./dist/manifest/bpmn-spec.js"
+        },
+        "./manifest/types": {
+            "types": "./dist/src/manifest/types.d.ts"
         }
     },
     "files": [
         "dist"
     ],
     "scripts": {
-        "build": "bun build ./src/index.ts --outdir dist --format esm --target node && tsc -p tsconfig.build.json --noCheck",
+        "build": "bun build ./src/index.ts ./src/manifest/bpmn-spec.ts --outdir dist --format esm --target node && tsc -p tsconfig.build.json --noCheck",
         "test": "vitest run",
         "test:coverage": "vitest run --coverage",
         "lint": "biome check ."
     },
     "devDependencies": {
-        "@uipath/auth": "0.9.1",
-        "@uipath/common": "0.9.1",
-        "@uipath/filesystem": "0.9.1",
-        "@uipath/flow-core": "^0.2.0",
-        "@uipath/integrationservice-sdk": "0.9.1",
-        "@uipath/orchestrator-sdk": "0.9.1",
-        "@types/node": "^25.5.0",
+        "@uipath/auth": "1.0.2",
+        "@uipath/common": "1.0.2",
+        "@uipath/filesystem": "1.0.2",
+        "@uipath/flow-core": "^0.2.205",
+        "@uipath/integrationservice-sdk": "1.0.1",
+        "@uipath/orchestrator-sdk": "1.0.0",
+        "@types/node": "^25.5.2",
         "commander": "^14.0.3",
-        "typescript": "^5"
+        "typescript": "^6.0.2"
     },
-    "gitHead": "e8da2857e37a9495c4907cd39f47c9d6ed1a5566"
+    "gitHead": "e373bfc1657e0bd85a7dc482691f4bda590392e5"
 }