Send GraphQL-Features header for issue intent mutations when issue_intents runtime feature is enabled (#41425)

Author: Copilot

actions/setup/js/set_issue_field.cjs

@@ -157,9 +157,18 @@ function buildFieldUpdatePayload(field, rawValue) {
  * @param {Object} githubClient - Authenticated GitHub client
  * @param {string} issueNodeId - GraphQL node ID of the issue
  * @param {{fieldId: string, singleSelectOptionId?: string, numberValue?: number, dateValue?: string, textValue?: string, rationale?: string, confidence?: "LOW"|"MEDIUM"|"HIGH", suggest?: boolean}} fieldUpdate
+ * @param {boolean} [useIntentHeader] - When true, includes the GraphQL-Features header to expose intent input types
  * @returns {Promise<void>}
  */
-async function setIssueFieldValue(githubClient, issueNodeId, fieldUpdate) {
+async function setIssueFieldValue(githubClient, issueNodeId, fieldUpdate, useIntentHeader) {
+  /** @type {Record<string, unknown>} */
+  const variables = {
+    issueId: issueNodeId,
+    issueFields: [fieldUpdate],
+  };
+  if (useIntentHeader) {
+    variables.headers = { "GraphQL-Features": "update_issue_suggestions" };
+  }
   await githubClient.graphql(
     `mutation($issueId: ID!, $issueFields: [IssueFieldCreateOrUpdateInput!]!) {
       setIssueFieldValue(input: { issueId: $issueId, issueFields: $issueFields }) {
@@ -168,10 +177,7 @@ async function setIssueFieldValue(githubClient, issueNodeId, fieldUpdate) {
         }
       }
     }`,
-    {
-      issueId: issueNodeId,
-      issueFields: [fieldUpdate],
-    }
+    variables
   );
 }
 
@@ -349,11 +355,13 @@ async function main(config = {}) {
         ...fieldUpdateResult.update,
       };
 
-      if (hasIssueIntentsRuntimeFeature()) {
+      const useIntentHeader = hasIssueIntentsRuntimeFeature();
+      if (useIntentHeader) {
         Object.assign(fieldUpdate, normalizeIssueIntentMetadata(item));
+        core.info(`Using GraphQL-Features header for issue field mutation (issue_intents runtime feature enabled)`);
       }
 
-      await setIssueFieldValue(githubClient, issueNodeId, fieldUpdate);
+      await setIssueFieldValue(githubClient, issueNodeId, fieldUpdate, useIntentHeader);
 
       core.info(`Successfully set issue field ${JSON.stringify(fieldName || fieldNodeId)} to ${JSON.stringify(value)} on issue #${issueNumber}`);
 

actions/setup/js/set_issue_field.test.cjs

@@ -447,6 +447,7 @@ describe("set_issue_field (Handler Factory Architecture)", () => {
               suggest: true,
             }),
           ],
+          headers: { "GraphQL-Features": "update_issue_suggestions" },
         })
       );
     } finally {

actions/setup/js/set_issue_type.cjs

@@ -20,6 +20,69 @@ const AVAILABLE_TYPES_PATTERNS = [/one of:\s*(.+)$/i, /available(?: types?)?:\s*
 const NO_ISSUE_TYPES_PATTERNS = [/no issue types? (?:are )?available/i, /issue types? (?:is|are) not (?:enabled|configured)/i];
 const NO_ISSUE_TYPES_AVAILABLE_ERROR = "No issue types are available for this repository. Issue types must be configured in the repository or organization settings.";
 
+/**
+ * Fetches the node ID of an issue for use in GraphQL mutations.
+ * @param {Object} githubClient - Authenticated GitHub client
+ * @param {string} owner - Repository owner
+ * @param {string} repo - Repository name
+ * @param {number} issueNumber - Issue number
+ * @returns {Promise<string>} Issue node ID
+ */
+async function getIssueNodeId(githubClient, owner, repo, issueNumber) {
+  const { data } = await githubClient.rest.issues.get({ owner, repo, issue_number: issueNumber });
+  return data.node_id;
+}
+
+/**
+ * Fetches the available issue types for an organization.
+ * For personal-account owners the query returns null and the call site receives an empty array.
+ * @param {Object} githubClient - Authenticated GitHub client
+ * @param {string} owner - Organization login
+ * @returns {Promise<Array<{id: string, name: string}>>} Issue type nodes
+ */
+async function fetchIssueTypesForOrg(githubClient, owner) {
+  const result = await githubClient.graphql(
+    `query($owner: String!) {
+      organization(login: $owner) {
+        issueTypes(first: 100) {
+          nodes {
+            id
+            name
+          }
+        }
+      }
+    }`,
+    { owner }
+  );
+  return result?.organization?.issueTypes?.nodes ?? [];
+}
+
+/**
+ * Sets the issue type via GraphQL mutation using `IssueTypeUpdateInput`.
+ * @param {Object} githubClient - Authenticated GitHub client
+ * @param {string} issueNodeId - GraphQL node ID of the issue
+ * @param {string} issueTypeId - GraphQL node ID of the issue type
+ * @param {{ rationale?: string, confidence?: "LOW"|"MEDIUM"|"HIGH", suggest?: boolean }} intentMetadata - Intent metadata in GraphQL format
+ * @returns {Promise<void>}
+ */
+async function setIssueTypeById(githubClient, issueNodeId, issueTypeId, intentMetadata) {
+  const issueType = { id: issueTypeId, ...intentMetadata };
+  await githubClient.graphql(
+    `mutation($issueId: ID!, $issueType: IssueTypeUpdateInput!) {
+      updateIssue(input: { id: $issueId, issueType: $issueType }) {
+        issue {
+          id
+        }
+      }
+    }`,
+    {
+      issueId: issueNodeId,
+      issueType,
+      headers: { "GraphQL-Features": "update_issue_suggestions" },
+    }
+  );
+}
+
 /**
  * @param {{ rationale?: string, confidence?: "LOW"|"MEDIUM"|"HIGH", suggest?: boolean }} intentMetadata Intent metadata in GraphQL format.
  * @returns {{ rationale?: string, confidence?: "low"|"medium"|"high", suggest?: boolean }} Intent metadata formatted for REST.
@@ -271,13 +334,35 @@ async function main(config = {}) {
     try {
       const { owner, repo } = repoParts;
       const intentMetadata = normalizeIssueIntentMetadata(item);
-      const typeValue = buildIssueTypeValue(isClear, resolvedIssueTypeName, intentMetadata);
-      await githubClient.rest.issues.update({
-        owner,
-        repo,
-        issue_number: issueNumber,
-        type: typeValue,
-      });
+
+      if (hasIssueIntentsRuntimeFeature() && !isClear) {
+        // GraphQL intent path: resolve the type's node ID from org issue types, then
+        // call setIssueTypeById with IssueTypeUpdateInput + the GraphQL-Features header.
+        core.info(`Using GraphQL intent path (issue_intents runtime feature enabled)`);
+        core.info(`Fetching issue node ID for issue #${issueNumber}`);
+        const issueNodeId = await getIssueNodeId(githubClient, owner, repo, issueNumber);
+        core.info(`Fetching issue types for org ${owner}`);
+        const issueTypes = await fetchIssueTypesForOrg(githubClient, owner);
+        core.info(`Found ${issueTypes.length} issue type(s) for org ${owner}`);
+        const typeNode = issueTypes.find(t => t.name.toLowerCase() === resolvedIssueTypeName.toLowerCase());
+        if (!typeNode) {
+          const availableNames = issueTypes.map(t => t.name).join(", ");
+          const error = availableNames ? `Issue type ${JSON.stringify(resolvedIssueTypeName)} not found. Available types: ${availableNames}` : NO_ISSUE_TYPES_AVAILABLE_ERROR;
+          core.error(`Failed to set issue type on issue #${issueNumber}: ${error}`);
+          return { success: false, error };
+        }
+        core.info(`Resolved issue type ${JSON.stringify(resolvedIssueTypeName)} to node ID ${typeNode.id}`);
+        await setIssueTypeById(githubClient, issueNodeId, typeNode.id, intentMetadata);
+      } else {
+        // REST path: used for the clear case and when the issue_intents feature is off.
+        const typeValue = buildIssueTypeValue(isClear, resolvedIssueTypeName, intentMetadata);
+        await githubClient.rest.issues.update({
+          owner,
+          repo,
+          issue_number: issueNumber,
+          type: typeValue,
+        });
+      }
 
       const successMsg = isClear ? `Successfully cleared issue type on issue #${issueNumber}` : `Successfully set issue type to ${JSON.stringify(resolvedIssueTypeName)} on issue #${issueNumber}`;
       core.info(successMsg);

actions/setup/js/set_issue_type.test.cjs

@@ -33,6 +33,7 @@ const mockGithub = {
       update: vi.fn(),
     },
   },
+  graphql: vi.fn(),
 };
 
 global.core = mockCore;
@@ -325,9 +326,29 @@ describe("set_issue_type (Handler Factory Architecture)", () => {
     );
   });
 
-  it("should pass issue intent metadata when runtime feature is enabled", async () => {
+  it("should use GraphQL intent path with IssueTypeUpdateInput and GraphQL-Features header when runtime feature is enabled", async () => {
     process.env.GH_AW_RUNTIME_FEATURES = "issue_intents";
 
+    const issueNodeId = "I_kwDO_testissue";
+    const issueTypeNodeId = "IT_kwDO_bug";
+
+    mockGithub.rest.issues.get.mockResolvedValueOnce({ data: { node_id: issueNodeId } });
+    mockGithub.graphql.mockImplementation(async query => {
+      if (query.includes("organization(login")) {
+        return {
+          organization: {
+            issueTypes: {
+              nodes: [{ id: issueTypeNodeId, name: "Bug" }],
+            },
+          },
+        };
+      }
+      if (query.includes("updateIssue")) {
+        return { updateIssue: { issue: { id: issueNodeId } } };
+      }
+      return {};
+    });
+
     try {
       const { main } = require("./set_issue_type.cjs");
       const featureHandler = await main({ max: 5 });
@@ -345,15 +366,18 @@ describe("set_issue_type (Handler Factory Architecture)", () => {
       );
 
       expect(result.success).toBe(true);
-      expect(mockGithub.rest.issues.update).toHaveBeenCalledWith(
+      expect(mockGithub.rest.issues.update).not.toHaveBeenCalled();
+      expect(mockGithub.graphql).toHaveBeenCalledWith(
+        expect.stringContaining("IssueTypeUpdateInput"),
         expect.objectContaining({
-          issue_number: 42,
-          type: {
-            value: "Bug",
+          issueId: issueNodeId,
+          issueType: {
+            id: issueTypeNodeId,
             rationale: "Author explicitly requests a bug fix",
-            confidence: "high",
+            confidence: "HIGH",
             suggest: true,
           },
+          headers: { "GraphQL-Features": "update_issue_suggestions" },
         })
       );
     } finally {

actions/setup/js/update_issue.cjs

@@ -135,9 +135,11 @@ async function executeIssueUpdate(github, context, issueNumber, updateData) {
       throw new Error(`Failed to resolve GraphQL node ID for issue #${issueNumber}`);
     }
 
+    core.info(`Using GraphQL intent path for label update with GraphQL-Features header (issue_intents runtime feature enabled)`);
     const repoLabels = await fetchAllRepoLabels(github, context.repo.owner, context.repo.repo);
     const labelIdByName = new Map(repoLabels.map(label => [label.name.toLowerCase(), label.id]));
     const labels = buildIssueIntentLabelUpdates(labelSpecs, labelIdByName);
+    core.info(`Updating ${labels.length} label(s) on issue #${issueNumber} via GraphQL intent mutation`);
     const result = await github.graphql(
       `mutation($issueId: ID!, $labels: [LabelUpdateInput!]!) {
         updateIssue(input: { id: $issueId, labels: $labels }) {
@@ -151,7 +153,7 @@ async function executeIssueUpdate(github, context, issueNumber, updateData) {
           }
         }
       }`,
-      { issueId: issueNodeId, labels }
+      { issueId: issueNodeId, labels, headers: { "GraphQL-Features": "update_issue_suggestions" } }
     );
 
     issue = {

actions/setup/js/update_issue.test.cjs

@@ -1016,6 +1016,7 @@ describe("update_issue.cjs - cross-repo and operation integration", () => {
               suggest: true,
             },
           ],
+          headers: { "GraphQL-Features": "update_issue_suggestions" },
         })
       );
     } finally {