powerautomate-mcp 0.8.0 → 0.9.0

package/dist/index.js

@@ -1518,6 +1518,30 @@ var FlowManagementApi = class {
       return data;
     }, "Fetch resource link");
   }
+  async getFlowRunActionRepetitions(flowId, runId, actionName, environmentId) {
+    const envId = environmentId ?? this.defaultEnvironmentId;
+    const safeFlowId = validateRowId(flowId);
+    const safeRunId = validateFlowRunId(runId);
+    const safeActionName = encodeURIComponent(actionName);
+    apiLogger.debug({ flowId: safeFlowId, runId: safeRunId, actionName }, "Getting action repetitions");
+    const url = this.buildUrl(
+      envId,
+      `/flows/${safeFlowId}/runs/${safeRunId}/actions/${safeActionName}/repetitions`
+    );
+    const headers = await this.getAuthHeaders();
+    return wrapApiCall(async () => {
+      const response = await request(url, { method: "GET", headers });
+      const data = await this.handleResponse(
+        response,
+        `Get repetitions for action ${actionName}`
+      );
+      apiLogger.info(
+        { flowId, runId, actionName, count: data.value.length },
+        "Retrieved action repetitions"
+      );
+      return data.value;
+    }, `Get repetitions for action ${actionName}`);
+  }
   // ==========================================================================
   // Flow Sharing & Permissions
   // ==========================================================================
@@ -6872,11 +6896,14 @@ var getRunActionsInputSchema = z.object({
   flowId: z.string().describe("The flow ID (GUID)"),
   runId: z.string().describe("The run ID (GUID)"),
   environment: z.string().optional().describe("Environment name or GUID. Uses default if omitted."),
-  failedOnly: z.boolean().optional().describe("If true, only return failed actions (default: false)")
+  failedOnly: z.boolean().optional().describe("If true, only return failed actions (default: false)"),
+  includeInputs: z.boolean().optional().describe("If true, fetch and display input data for each action (default: false for succeeded, true for failed)"),
+  includeOutputs: z.boolean().optional().describe("If true, fetch and display output data for each action (default: false for succeeded, true for failed)"),
+  actionName: z.string().optional().describe("Filter to a specific action by name (partial match). Use to drill into one action's details.")
 });
 var getRunActionsTool = {
   name: "get_run_actions",
-  description: "Get detailed action-level information for a flow run. Shows each action's status, timing, and most importantly - error details for failed actions. Essential for debugging why a flow failed. Use 'failedOnly: true' to focus on just the failures.",
+  description: "Get detailed action-level information for a flow run. Shows each action's status, timing, inputs/outputs, and error details. Use 'failedOnly: true' to focus on failures, 'actionName' to drill into a specific action, 'includeInputs'/'includeOutputs' to see full data payloads.",
   inputSchema: {
     type: "object",
     properties: {
@@ -6895,11 +6922,34 @@ var getRunActionsTool = {
       failedOnly: {
         type: "boolean",
         description: "If true, only return failed actions (default: false)"
+      },
+      includeInputs: {
+        type: "boolean",
+        description: "If true, fetch and display input data for each action (default: false for succeeded, true for failed)"
+      },
+      includeOutputs: {
+        type: "boolean",
+        description: "If true, fetch and display output data for each action (default: false for succeeded, true for failed)"
+      },
+      actionName: {
+        type: "string",
+        description: "Filter to a specific action by name (partial match). Use to drill into one action's details."
       }
     },
     required: ["flowId", "runId"]
   }
 };
+var TRUNCATE_LIMIT = 1e3;
+var ERROR_TRUNCATE_LIMIT = 500;
+function formatResourceData(data) {
+  if (data && typeof data === "object" && "body" in data) {
+    const body = data.body;
+    const str2 = typeof body === "object" ? JSON.stringify(body, null, 2) : String(body);
+    return str2.length > TRUNCATE_LIMIT ? str2.slice(0, TRUNCATE_LIMIT) + "\u2026" : str2;
+  }
+  const str = JSON.stringify(data, null, 2);
+  return str.length > TRUNCATE_LIMIT ? str.slice(0, TRUNCATE_LIMIT) + "\u2026" : str;
+}
 async function handleGetRunActions(api, input) {
   const parsed = getRunActionsInputSchema.parse(input);
   logger.info({ input: parsed }, "Executing get_run_actions");
@@ -6909,38 +6959,70 @@ async function handleGetRunActions(api, input) {
     parsed.environment
   );
   let filteredActions = actions;
+  if (parsed.actionName) {
+    const needle = parsed.actionName.toLowerCase();
+    filteredActions = filteredActions.filter(
+      (a) => a.name.toLowerCase().includes(needle)
+    );
+  }
   if (parsed.failedOnly) {
-    filteredActions = actions.filter(
+    filteredActions = filteredActions.filter(
       (a) => a.properties.status === "Failed" || a.properties.status === "TimedOut"
     );
   }
-  const keyActionNames = ["Result", "Debug_Sample", "Debug_F1", "Final_Count"];
-  const outputsToFetch = [];
+  const shouldFetchInputs = (status) => {
+    if (parsed.includeInputs === true) return true;
+    if (parsed.includeInputs === false) return false;
+    return status === "Failed" || status === "TimedOut";
+  };
+  const shouldFetchOutputs = (status) => {
+    if (parsed.includeOutputs === true) return true;
+    if (parsed.includeOutputs === false) return false;
+    return status === "Failed" || status === "TimedOut";
+  };
+  const actionIO = {};
+  const fetchPromises = [];
   for (const action of filteredActions) {
-    const isKeyAction = keyActionNames.some((k) => action.name.includes(k) || action.name === k);
-    if (isKeyAction && action.properties.outputsLink?.uri) {
-      outputsToFetch.push({ name: action.name, uri: action.properties.outputsLink.uri });
+    const status = action.properties.status;
+    const needInputs = shouldFetchInputs(status) && action.properties.inputsLink?.uri;
+    const needOutputs = shouldFetchOutputs(status) && action.properties.outputsLink?.uri;
+    if (needInputs) {
+      fetchPromises.push(
+        api.fetchResourceLink(action.properties.inputsLink.uri).then(
+          (data) => {
+            if (!actionIO[action.name]) actionIO[action.name] = {};
+            actionIO[action.name].inputs = formatResourceData(data);
+          },
+          (err) => {
+            if (!actionIO[action.name]) actionIO[action.name] = {};
+            const msg = err instanceof Error ? err.message : String(err);
+            actionIO[action.name].inputs = `(fetch error: ${msg.slice(0, 100)})`;
+          }
+        )
+      );
     }
-  }
-  const actionOutputs = {};
-  for (const { name, uri } of outputsToFetch) {
-    try {
-      const output = await api.fetchResourceLink(uri);
-      if (output && typeof output === "object" && "body" in output) {
-        const body = output.body;
-        actionOutputs[name] = typeof body === "object" ? JSON.stringify(body).slice(0, 200) : String(body);
-      } else {
-        actionOutputs[name] = JSON.stringify(output).slice(0, 200);
-      }
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      actionOutputs[name] = `(error: ${msg.slice(0, 50)})`;
+    if (needOutputs) {
+      fetchPromises.push(
+        api.fetchResourceLink(action.properties.outputsLink.uri).then(
+          (data) => {
+            if (!actionIO[action.name]) actionIO[action.name] = {};
+            actionIO[action.name].outputs = formatResourceData(data);
+          },
+          (err) => {
+            if (!actionIO[action.name]) actionIO[action.name] = {};
+            const msg = err instanceof Error ? err.message : String(err);
+            actionIO[action.name].outputs = `(fetch error: ${msg.slice(0, 100)})`;
+          }
+        )
+      );
     }
   }
-  const result = filteredActions.map((action) => {
+  await Promise.all(fetchPromises);
+  const results = filteredActions.map((action) => {
     const props = action.properties;
     const startTime = new Date(props.startTime);
     const endTime = props.endTime ? new Date(props.endTime) : void 0;
+    const io = actionIO[action.name];
     return {
       name: action.name,
       status: props.status,
@@ -6948,25 +7030,213 @@ async function handleGetRunActions(api, input) {
       endTime: props.endTime,
       durationMs: endTime ? endTime.getTime() - startTime.getTime() : void 0,
       error: props.error,
-      retryCount: props.retryHistory?.length
+      inputs: io?.inputs,
+      outputs: io?.outputs,
+      retryCount: props.retryHistory?.length,
+      trackedProperties: props.trackedProperties
     };
   });
-  const failedCount = result.filter((r) => r.status === "Failed" || r.status === "TimedOut").length;
-  const succeededCount = result.filter((r) => r.status === "Succeeded").length;
-  const lines = [`Actions: ${result.length} total (${succeededCount} succeeded, ${failedCount} failed)`];
-  if (Object.keys(actionOutputs).length > 0) {
-    lines.push("\nOutputs:");
-    for (const [name, value] of Object.entries(actionOutputs)) {
-      lines.push(`  ${name}: ${value}`);
-    }
-    lines.push("");
+  const failedCount = results.filter(
+    (r) => r.status === "Failed" || r.status === "TimedOut"
+  ).length;
+  const succeededCount = results.filter(
+    (r) => r.status === "Succeeded"
+  ).length;
+  const lines = [
+    `Actions: ${results.length} total (${succeededCount} succeeded, ${failedCount} failed)`
+  ];
+  if (parsed.actionName) {
+    lines[0] += ` [filtered by "${parsed.actionName}"]`;
   }
-  for (const action of result) {
+  for (const action of results) {
     const duration = action.durationMs ? `${(action.durationMs / 1e3).toFixed(1)}s` : "";
-    const status = action.status === "Succeeded" ? "\u2713" : action.status === "Failed" ? "\u2717" : "\u25CB";
-    let line = `  ${status} ${action.name} ${duration}`;
+    const status = action.status === "Succeeded" ? "\u2713" : action.status === "Failed" ? "\u2717" : action.status === "TimedOut" ? "\u23F1" : "\u25CB";
+    let line = `
+  ${status} ${action.name} ${duration}`;
     if (action.error) {
-      line += ` - ${action.error.message.slice(0, 100)}`;
+      line += `
+    Error: [${action.error.code}] ${action.error.message.slice(0, ERROR_TRUNCATE_LIMIT)}`;
+    }
+    if (action.inputs) {
+      line += `
+    Inputs: ${action.inputs}`;
+    }
+    if (action.outputs) {
+      line += `
+    Outputs: ${action.outputs}`;
+    }
+    if (action.trackedProperties && Object.keys(action.trackedProperties).length > 0) {
+      line += `
+    Tracked: ${JSON.stringify(action.trackedProperties)}`;
+    }
+    if (action.retryCount && action.retryCount > 0) {
+      line += `
+    Retries: ${action.retryCount}`;
+    }
+    lines.push(line);
+  }
+  return lines.join("\n");
+}
+var getRunActionRepetitionsInputSchema = z.object({
+  flowId: z.string().describe("The flow ID (GUID)"),
+  runId: z.string().describe("The run ID (GUID)"),
+  actionName: z.string().describe("The exact action name inside the for_each/do_until loop"),
+  environment: z.string().optional().describe("Environment name or GUID. Uses default if omitted."),
+  failedOnly: z.boolean().optional().describe("If true, only return failed iterations (default: false)"),
+  includeInputs: z.boolean().optional().describe("If true, fetch input data for each iteration (default: false)"),
+  includeOutputs: z.boolean().optional().describe("If true, fetch output data for each iteration (default: true for failed)"),
+  maxIterations: z.number().optional().describe("Maximum iterations to return (default: 50). Use to limit large loops.")
+});
+var getRunActionRepetitionsTool = {
+  name: "get_run_action_repetitions",
+  description: "Get iteration-level details for a for_each or do_until loop action in a flow run. Shows which iterations succeeded/failed, their inputs/outputs, and error details. Essential for debugging loops that partially fail.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      flowId: {
+        type: "string",
+        description: "The flow ID (GUID)"
+      },
+      runId: {
+        type: "string",
+        description: "The run ID (GUID)"
+      },
+      actionName: {
+        type: "string",
+        description: "The exact action name inside the for_each/do_until loop"
+      },
+      environment: {
+        type: "string",
+        description: "Environment name or GUID. Uses default if omitted."
+      },
+      failedOnly: {
+        type: "boolean",
+        description: "If true, only return failed iterations (default: false)"
+      },
+      includeInputs: {
+        type: "boolean",
+        description: "If true, fetch input data for each iteration (default: false)"
+      },
+      includeOutputs: {
+        type: "boolean",
+        description: "If true, fetch output data for each iteration (default: true for failed)"
+      },
+      maxIterations: {
+        type: "number",
+        description: "Maximum iterations to return (default: 50). Use to limit large loops."
+      }
+    },
+    required: ["flowId", "runId", "actionName"]
+  }
+};
+var TRUNCATE_LIMIT2 = 1e3;
+function formatData(data) {
+  if (data && typeof data === "object" && "body" in data) {
+    const body = data.body;
+    const str2 = typeof body === "object" ? JSON.stringify(body, null, 2) : String(body);
+    return str2.length > TRUNCATE_LIMIT2 ? str2.slice(0, TRUNCATE_LIMIT2) + "\u2026" : str2;
+  }
+  const str = JSON.stringify(data, null, 2);
+  return str.length > TRUNCATE_LIMIT2 ? str.slice(0, TRUNCATE_LIMIT2) + "\u2026" : str;
+}
+async function handleGetRunActionRepetitions(api, input) {
+  const parsed = getRunActionRepetitionsInputSchema.parse(input);
+  const maxIter = parsed.maxIterations ?? 50;
+  logger.info({ input: parsed }, "Executing get_run_action_repetitions");
+  const repetitions = await api.getFlowRunActionRepetitions(
+    parsed.flowId,
+    parsed.runId,
+    parsed.actionName,
+    parsed.environment
+  );
+  let filtered = repetitions;
+  if (parsed.failedOnly) {
+    filtered = filtered.filter(
+      (r) => r.properties.status === "Failed" || r.properties.status === "TimedOut"
+    );
+  }
+  const totalCount = filtered.length;
+  filtered = filtered.slice(0, maxIter);
+  const shouldFetchInputs = (status) => {
+    if (parsed.includeInputs === true) return true;
+    return false;
+  };
+  const shouldFetchOutputs = (status) => {
+    if (parsed.includeOutputs === true) return true;
+    if (parsed.includeOutputs === false) return false;
+    return status === "Failed" || status === "TimedOut";
+  };
+  const iterIO = {};
+  const fetchPromises = [];
+  for (const rep of filtered) {
+    const status = rep.properties.status;
+    const key = rep.name;
+    if (shouldFetchInputs() && rep.properties.inputsLink?.uri) {
+      fetchPromises.push(
+        api.fetchResourceLink(rep.properties.inputsLink.uri).then(
+          (data) => {
+            if (!iterIO[key]) iterIO[key] = {};
+            iterIO[key].inputs = formatData(data);
+          },
+          (err) => {
+            if (!iterIO[key]) iterIO[key] = {};
+            const msg = err instanceof Error ? err.message : String(err);
+            iterIO[key].inputs = `(fetch error: ${msg.slice(0, 100)})`;
+          }
+        )
+      );
+    }
+    if (shouldFetchOutputs(status) && rep.properties.outputsLink?.uri) {
+      fetchPromises.push(
+        api.fetchResourceLink(rep.properties.outputsLink.uri).then(
+          (data) => {
+            if (!iterIO[key]) iterIO[key] = {};
+            iterIO[key].outputs = formatData(data);
+          },
+          (err) => {
+            if (!iterIO[key]) iterIO[key] = {};
+            const msg = err instanceof Error ? err.message : String(err);
+            iterIO[key].outputs = `(fetch error: ${msg.slice(0, 100)})`;
+          }
+        )
+      );
+    }
+  }
+  await Promise.all(fetchPromises);
+  const failedCount = filtered.filter(
+    (r) => r.properties.status === "Failed" || r.properties.status === "TimedOut"
+  ).length;
+  const succeededCount = filtered.filter(
+    (r) => r.properties.status === "Succeeded"
+  ).length;
+  const lines = [
+    `Repetitions for "${parsed.actionName}": ${totalCount} total (${succeededCount} succeeded, ${failedCount} failed)`
+  ];
+  if (totalCount > maxIter) {
+    lines.push(`  (showing first ${maxIter} of ${totalCount})`);
+  }
+  for (const rep of filtered) {
+    const props = rep.properties;
+    const startTime = new Date(props.startTime);
+    const endTime = props.endTime ? new Date(props.endTime) : void 0;
+    const durationMs = endTime ? endTime.getTime() - startTime.getTime() : void 0;
+    const duration = durationMs ? `${(durationMs / 1e3).toFixed(1)}s` : "";
+    const indexes = props.repetitionIndexes?.map((ri) => `${ri.scopeName}[${ri.itemIndex}]`).join(" > ");
+    const status = props.status === "Succeeded" ? "\u2713" : props.status === "Failed" ? "\u2717" : props.status === "TimedOut" ? "\u23F1" : "\u25CB";
+    let line = `
+  ${status} ${indexes ?? rep.name} ${duration}`;
+    if (props.error) {
+      line += `
+    Error: [${props.error.code}] ${props.error.message.slice(0, 500)}`;
+    }
+    const io = iterIO[rep.name];
+    if (io?.inputs) {
+      line += `
+    Inputs: ${io.inputs}`;
+    }
+    if (io?.outputs) {
+      line += `
+    Outputs: ${io.outputs}`;
     }
     lines.push(line);
   }
@@ -12923,6 +13193,7 @@ var tools = [
   // Phase 4: Connections, Diagnostics, Sharing
   listConnectionsTool,
   getRunActionsTool,
+  getRunActionRepetitionsTool,
   getFlowPermissionsTool,
   shareFlowTool,
   // Phase 5: Run Control, Environment Management
@@ -13058,6 +13329,9 @@ async function executeTool(context, toolName, input) {
       case "get_run_actions":
         result = await handleGetRunActions(context.flowApi, input);
         break;
+      case "get_run_action_repetitions":
+        result = await handleGetRunActionRepetitions(context.flowApi, input);
+        break;
       case "get_flow_permissions":
         result = await handleGetFlowPermissions(context.flowApi, input);
         break;