fix(github): report the raw page length from list_repository_issues

list_repository_issues fetches one GitHub page and filters pull
requests out of it, which destroys the only pagination signal
page-number callers have: the filtered array's length says nothing
about the raw page length. A short page may be a full page with PRs
mixed in, and an empty page may be 100 consecutive PRs — so any
paginating consumer that stops on a short or empty page silently drops
every later issue, and no sound termination rule can be built from the
filtered response alone.

The response now carries pageInfo.fetched — the number of items GitHub
returned before filtering — declared in the output schema and in the
action description: callers must continue paginating while fetched
equals the requested page size, even when issues comes back short or
empty. The PR filtering behavior itself is unchanged.

Tests cover the mixed page (fetched=3, issues=[1,3]), the
all-pull-requests page (fetched=2, issues=[]), and the schema
declaration.

Author: bakey

src/providers/github/actions.ts

@@ -757,7 +757,8 @@ export const githubActions: ActionDefinition[] = [
   }),
   action({
     name: "list_repository_issues",
-    description: "List issues for a GitHub repository. Pull requests are filtered out from the response.",
+    description:
+      "List issues for a GitHub repository. Pull requests are filtered out of the response; pageInfo.fetched reports the raw page length before filtering, so paginating callers must continue while fetched equals the requested page size even when the issues array comes back short or empty.",
     requiredScopes: githubRepoScopes,
     inputSchema: s.object({
       owner: nonEmptyString,
@@ -771,6 +772,16 @@ export const githubActions: ActionDefinition[] = [
     }),
     outputSchema: s.object({
       issues: s.array(githubIssueSchema),
+      pageInfo: s.requiredObject(
+        "Pagination signals from the raw GitHub page, before pull requests are filtered out.",
+        {
+          fetched: s.integer({
+            minimum: 0,
+            description:
+              "Number of items GitHub returned on this page before filtering. Continue paginating while this equals the requested page size.",
+          }),
+        },
+      ),
     }),
   }),
   action({

src/providers/github/runtime-issue.test.ts

@@ -0,0 +1,63 @@
+import { describe, expect, it } from "vitest";
+import { provider } from "./definition.ts";
+import { issueActionHandlers } from "./runtime-issue.ts";
+
+function pageFetcher(items: unknown[]): typeof fetch {
+  return async () =>
+    new Response(JSON.stringify(items), {
+      status: 200,
+      headers: { "content-type": "application/json" },
+    });
+}
+
+describe("list_repository_issues pagination signal", () => {
+  it("reports the raw page length before pull requests are filtered out", async () => {
+    // A raw GitHub page of 3 items where one is a pull request. The
+    // filtered `issues` array alone would read as a short page and stop
+    // page-number pagination early; `pageInfo.fetched` preserves the raw
+    // length so callers can keep paginating correctly.
+    const result = (await issueActionHandlers.list_repository_issues(
+      { owner: "acme", repo: "widgets", perPage: 3 },
+      {
+        accessToken: "token",
+        fetcher: pageFetcher([
+          { id: 1, number: 10, title: "real issue" },
+          { id: 2, number: 11, title: "a pull request", pull_request: { url: "https://example.test" } },
+          { id: 3, number: 12, title: "another issue" },
+        ]),
+      },
+    )) as { issues: Array<{ id: number }>; pageInfo: { fetched: number } };
+
+    expect(result.issues.map((issue) => issue.id)).toEqual([1, 3]);
+    expect(result.pageInfo.fetched).toBe(3);
+  });
+
+  it("reports fetched on an all-pull-request page whose issues array is empty", async () => {
+    const result = (await issueActionHandlers.list_repository_issues(
+      { owner: "acme", repo: "widgets", perPage: 2 },
+      {
+        accessToken: "token",
+        fetcher: pageFetcher([
+          { id: 1, pull_request: {} },
+          { id: 2, pull_request: {} },
+        ]),
+      },
+    )) as { issues: unknown[]; pageInfo: { fetched: number } };
+
+    expect(result.issues).toEqual([]);
+    expect(result.pageInfo.fetched).toBe(2);
+  });
+
+  it("declares pageInfo.fetched in the action's output schema", () => {
+    interface ObjectSchema {
+      properties?: Record<string, ObjectSchema>;
+      required?: string[];
+      type?: string;
+    }
+    const action = provider.actions.find((entry) => entry.name === "list_repository_issues");
+    const pageInfo = (action?.outputSchema as ObjectSchema | undefined)?.properties?.pageInfo;
+
+    expect(pageInfo?.properties?.fetched?.type).toBe("integer");
+    expect(pageInfo?.required).toContain("fetched");
+  });
+});

src/providers/github/runtime-issue.ts

@@ -289,7 +289,13 @@ async function listRepositoryIssues(input: Record<string, unknown>, accessToken:
   });
 
   return {
+    // The raw GitHub page mixes issues and pull requests; filtering PRs out
+    // destroys the only pagination signal page-number callers have (the raw
+    // page length). `pageInfo.fetched` preserves it: a caller must continue
+    // paginating while `fetched` equals the requested page size, even when
+    // `issues` comes back short or empty.
     issues: issues.filter((issue) => issue.pull_request == null),
+    pageInfo: { fetched: issues.length },
   };
 }