@octocodeai/octocode-tools-core 16.6.2 → 17.0.1

package/dist/tools/github_fetch_content/finalizer/types.d.ts

@@ -0,0 +1,101 @@
+import type { z } from 'zod';
+import type { FileContentQuerySchema } from '@octocodeai/octocode-core/schemas';
+type FileContentQuery = z.infer<typeof FileContentQuerySchema>;
+import type { PaginationInfo } from '../../../types/toolResults.js';
+import type { QueryWithPagination } from '../../../utils/response/groupedFinalizer.js';
+import type { GitHubFetchContentOutputLocal } from '../scheme.js';
+import type { WithOptionalMeta } from '../../../types/execution.js';
+export type PartialFileContentQuery = WithOptionalMeta<FileContentQuery> & QueryWithPagination;
+export type FileEntry = {
+    path: string;
+    content: string;
+    localPath?: string;
+    repoRoot?: string;
+    fileSize?: number;
+    contentView?: 'none' | 'standard' | 'symbols';
+    totalLines?: number;
+    sourceChars?: number;
+    sourceBytes?: number;
+    resolvedBranch?: string;
+    pagination?: PaginationInfo;
+    isPartial?: boolean;
+    startLine?: number;
+    endLine?: number;
+    matchRanges?: Array<{
+        start: number;
+        end: number;
+    }>;
+    lastModified?: string;
+    lastModifiedBy?: string;
+    warnings?: string[];
+    matchNotFound?: boolean;
+    searchedFor?: string;
+    cached?: boolean;
+    next?: FileContentNextMap;
+};
+export type FileContentNextMap = {
+    continueChars?: {
+        tool: 'ghGetFileContent';
+        query: Record<string, unknown>;
+    };
+    cloneForSemantics?: {
+        tool: 'ghCloneRepo';
+        query: Record<string, unknown>;
+        why: string;
+        confidence: 'exact';
+    };
+};
+export type DirectoryEntry = {
+    path: string;
+    localPath: string;
+    repoRoot?: string;
+    fileCount: number;
+    totalSize: number;
+    complete?: boolean;
+    verified?: boolean;
+    commitSha?: string;
+    hasSubdirectories?: boolean;
+    skippedSummary?: Record<string, number>;
+    directoryEntryCount?: number;
+    eligibleFileCount?: number;
+    savedFileCount?: number;
+    skipped?: {
+        nonFile: number;
+        missingDownloadUrl: number;
+        oversized: number;
+        binary: number;
+        fileLimit: number;
+        fetchFailed: number;
+        totalSizeLimit: number;
+        pathTraversal: number;
+    };
+    limits?: {
+        maxDirectoryFiles: number;
+        maxTotalSize: number;
+        maxFileSize: number;
+    };
+    warnings?: string[];
+    files?: Array<{
+        path: string;
+        size: number;
+        type: string;
+    }>;
+    cached?: boolean;
+    resolvedBranch?: string;
+};
+export type RepoGroup = {
+    id: string;
+    owner: string;
+    repo: string;
+    files?: FileEntry[];
+    directories?: DirectoryEntry[];
+    data?: RepoGroupData;
+};
+export type RepoGroupData = {
+    owner: string;
+    repo: string;
+    files?: FileEntry[];
+    directories?: DirectoryEntry[];
+};
+export type FileContentResponse = GitHubFetchContentOutputLocal;
+export {};

package/dist/tools/github_fetch_content/finalizer.d.ts

@@ -1,10 +1,4 @@
-import type { z } from 'zod';
-import type { FileContentQuerySchema } from '@octocodeai/octocode-core/schemas';
-type FileContentQuery = z.infer<typeof FileContentQuerySchema>;
 import type { BulkFinalizer } from '../../types/bulk.js';
-import { type QueryWithPagination } from '../../utils/response/groupedFinalizer.js';
 import type { GitHubFetchContentOutputLocal } from './scheme.js';
-import type { WithOptionalMeta } from '../../types/execution.js';
-type PartialFileContentQuery = WithOptionalMeta<FileContentQuery> & QueryWithPagination;
+import type { PartialFileContentQuery } from './finalizer/types.js';
 export declare function buildGithubFetchContentFinalizer<TQuery extends PartialFileContentQuery>(): BulkFinalizer<TQuery, GitHubFetchContentOutputLocal>;
-export {};

package/dist/tools/github_fetch_content/scheme.d.ts

@@ -63,27 +63,61 @@ export declare const GitHubFetchContentOutputLocalSchema: z.ZodObject<{
                     standard: "standard";
                     symbols: "symbols";
                 }>>;
-                isSkeleton: z.ZodOptional<z.ZodBoolean>;
                 totalLines: z.ZodOptional<z.ZodNumber>;
                 sourceChars: z.ZodOptional<z.ZodNumber>;
                 sourceBytes: z.ZodOptional<z.ZodNumber>;
                 resolvedBranch: z.ZodOptional<z.ZodString>;
-                pagination: z.ZodOptional<z.ZodObject<{
+                modified: z.ZodOptional<z.ZodString>;
+                fileSize: z.ZodOptional<z.ZodNumber>;
+                pagination: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                    charOffset: z.ZodNumber;
+                    charLength: z.ZodNumber;
+                    totalChars: z.ZodNumber;
+                    hasMore: z.ZodBoolean;
+                    nextCharOffset: z.ZodOptional<z.ZodNumber>;
+                    currentPage: z.ZodOptional<z.ZodNumber>;
+                    totalPages: z.ZodOptional<z.ZodNumber>;
+                    chunkMode: z.ZodOptional<z.ZodEnum<{
+                        semantic: "semantic";
+                        "char-limit": "char-limit";
+                    }>>;
+                    nextPage: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>, z.ZodObject<{
                     currentPage: z.ZodNumber;
                     totalPages: z.ZodNumber;
                     hasMore: z.ZodBoolean;
                     nextPage: z.ZodOptional<z.ZodNumber>;
-                    nextMatchPage: z.ZodOptional<z.ZodNumber>;
+                    pageSize: z.ZodOptional<z.ZodNumber>;
+                    totalItems: z.ZodOptional<z.ZodNumber>;
+                    perPage: z.ZodOptional<z.ZodNumber>;
+                    totalFound: z.ZodOptional<z.ZodNumber>;
+                    returned: z.ZodOptional<z.ZodNumber>;
+                    totalMatches: z.ZodOptional<z.ZodNumber>;
+                    reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
+                    reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
+                    totalMatchesKind: z.ZodOptional<z.ZodEnum<{
+                        exact: "exact";
+                        reported: "reported";
+                        lowerBound: "lowerBound";
+                    }>>;
+                    totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
+                    totalResults: z.ZodOptional<z.ZodNumber>;
+                    itemsPerPage: z.ZodOptional<z.ZodNumber>;
                     charOffset: z.ZodOptional<z.ZodNumber>;
                     charLength: z.ZodOptional<z.ZodNumber>;
                     totalChars: z.ZodOptional<z.ZodNumber>;
                     nextCharOffset: z.ZodOptional<z.ZodNumber>;
-                    filesPerPage: z.ZodOptional<z.ZodNumber>;
-                    totalFiles: z.ZodOptional<z.ZodNumber>;
-                    entriesPerPage: z.ZodOptional<z.ZodNumber>;
-                    totalEntries: z.ZodOptional<z.ZodNumber>;
-                    matchesPerPage: z.ZodOptional<z.ZodNumber>;
-                    totalMatches: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strip>]>>;
+                next: z.ZodOptional<z.ZodObject<{
+                    continueChars: z.ZodOptional<z.ZodObject<{
+                        query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                        why: z.ZodOptional<z.ZodString>;
+                        confidence: z.ZodOptional<z.ZodEnum<{
+                            exact: "exact";
+                            heuristic: "heuristic";
+                        }>>;
+                        tool: z.ZodLiteral<"ghGetFileContent">;
+                    }, z.core.$strip>>;
                 }, z.core.$strip>>;
                 isPartial: z.ZodOptional<z.ZodBoolean>;
                 startLine: z.ZodOptional<z.ZodNumber>;

package/dist/tools/github_fetch_content/types.d.ts

@@ -2,7 +2,7 @@ import type { z } from 'zod';
 import type { FileContentQuerySchema } from '@octocodeai/octocode-core/schemas';
 import type { MinifyMode } from '../../scheme/fields.js';
 type FileContentQuery = z.infer<typeof FileContentQuerySchema>;
-import type { PaginationInfo } from '../../utils/core/types.js';
+import type { PaginationInfo } from '../../types/toolResults.js';
 export type FileContentExecutionQuery = FileContentQuery & {
     noTimestamp?: boolean;
     minify: MinifyMode;
@@ -18,7 +18,6 @@ export interface GitHubFileContentApiData {
     path?: string;
     content?: string;
     contentView?: 'none' | 'standard' | 'symbols';
-    isSkeleton?: boolean;
     branch?: string;
     resolvedBranch?: string;
     startLine?: number;

package/dist/tools/github_search_code/execution.d.ts

@@ -4,5 +4,14 @@ import type { GitHubCodeSearchQuerySchema } from '@octocodeai/octocode-core/sche
 type GitHubCodeSearchQuery = z.infer<typeof GitHubCodeSearchQuerySchema>;
 import type { ToolExecutionArgs, WithOptionalMeta } from '../../types/execution.js';
 type PartialCodeSearchQuery = WithOptionalMeta<GitHubCodeSearchQuery>;
+export declare function hasValidCodeSearchParams(query: PartialCodeSearchQuery): boolean;
+export type RepoState = {
+    kind: 'notFound';
+} | {
+    kind: 'archived';
+} | {
+    kind: 'renamed';
+    fullName: string;
+};
 export declare function searchMultipleGitHubCode(args: ToolExecutionArgs<PartialCodeSearchQuery>): Promise<CallToolResult>;
 export {};

package/dist/tools/github_search_code/finalizer/build.d.ts

@@ -0,0 +1,4 @@
+import type { BulkFinalizer } from '../../../types/bulk.js';
+import { type QueryWithPagination } from '../../../utils/response/groupedFinalizer.js';
+import type { GitHubCodeSearchOutputLocal } from '../scheme.js';
+export declare function buildGhSearchCodeFinalizer<TQuery extends QueryWithPagination>(): BulkFinalizer<TQuery, GitHubCodeSearchOutputLocal>;

package/dist/tools/github_search_code/finalizer/groups.d.ts

@@ -0,0 +1,23 @@
+import { type QueryWithPagination } from '../../../utils/response/groupedFinalizer.js';
+import type { ToolContinuation } from '../../../scheme/pagination.js';
+import { type CodeSearchGroupedMatch, type CodeSearchGroupedResult, type CodeSearchPagination } from '../../providerMappers.js';
+export type PerQueryGroups = {
+    id: string;
+    groups: CodeSearchGroupedResult[];
+};
+export type CodeSearchFileResult = {
+    owner: string;
+    repo: string;
+    path: string;
+    matches: Array<Omit<CodeSearchGroupedMatch, 'path'>>;
+};
+export type CodeSearchResultRecord = {
+    id: string;
+    data: {
+        files: CodeSearchFileResult[];
+        pagination?: CodeSearchPagination;
+    };
+};
+export declare function mergeGroups(perQuery: readonly PerQueryGroups[]): CodeSearchGroupedResult[];
+export declare function buildResultRecords(queries: readonly QueryWithPagination[], groups: readonly CodeSearchGroupedResult[], paginationByQuery: ReadonlyMap<string, CodeSearchPagination>): CodeSearchResultRecord[];
+export declare function buildNextMap(resultRecords: readonly CodeSearchResultRecord[], queries: readonly QueryWithPagination[], allKeywords: readonly string[]): Record<string, ToolContinuation> | undefined;

package/dist/tools/github_search_code/finalizer/ranking.d.ts

@@ -0,0 +1,12 @@
+import type { FlatQueryResult } from '../../../types/toolResults.js';
+import { type QueryWithPagination } from '../../../utils/response/groupedFinalizer.js';
+import type { RepoState } from '../execution.js';
+import { type CodeSearchFlatResult, type CodeSearchGroupedResult } from '../../providerMappers.js';
+export declare function queryById(queries: readonly QueryWithPagination[]): ReadonlyMap<string, QueryWithPagination>;
+export declare function hasScopedGitHubQuery(emptyQueries: readonly {
+    id: string;
+}[], queries: readonly QueryWithPagination[]): boolean;
+export declare function readPerQueryFlat(result: FlatQueryResult): CodeSearchFlatResult & {
+    repoState?: RepoState;
+};
+export declare function applyExactMatchRanking(groups: readonly CodeSearchGroupedResult[], keywords: readonly string[]): CodeSearchGroupedResult[];

package/dist/tools/github_search_code/finalizer.d.ts

@@ -1,6 +1,2 @@
-import type { BulkFinalizer } from '../../types/bulk.js';
-import { type QueryWithPagination } from '../../utils/response/groupedFinalizer.js';
-import type { GitHubCodeSearchOutputLocal } from './scheme.js';
-import { type CodeSearchGroupedResult } from '../providerMappers.js';
-export declare function applyExactMatchRanking(groups: readonly CodeSearchGroupedResult[], keywords: readonly string[]): CodeSearchGroupedResult[];
-export declare function buildGhSearchCodeFinalizer<TQuery extends QueryWithPagination>(): BulkFinalizer<TQuery, GitHubCodeSearchOutputLocal>;
+export { applyExactMatchRanking } from './finalizer/ranking.js';
+export { buildGhSearchCodeFinalizer } from './finalizer/build.js';

package/dist/tools/github_search_code/scheme.d.ts

@@ -39,7 +39,7 @@ export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
     results: z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         data: z.ZodObject<{
-            files: z.ZodArray<z.ZodObject<{
+            files: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{
                 owner: z.ZodString;
                 repo: z.ZodString;
                 path: z.ZodString;
@@ -54,22 +54,28 @@ export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
                     }, z.core.$strip>>>;
                     url: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>>;
-            }, z.core.$strip>>;
+            }, z.core.$strip>]>>;
             pagination: z.ZodOptional<z.ZodObject<{
                 currentPage: z.ZodNumber;
                 totalPages: z.ZodNumber;
-                perPage: z.ZodNumber;
-                totalMatches: z.ZodNumber;
+                hasMore: z.ZodBoolean;
+                nextPage: z.ZodOptional<z.ZodNumber>;
+                pageSize: z.ZodOptional<z.ZodNumber>;
+                totalItems: z.ZodOptional<z.ZodNumber>;
+                perPage: z.ZodOptional<z.ZodNumber>;
+                totalFound: z.ZodOptional<z.ZodNumber>;
+                returned: z.ZodOptional<z.ZodNumber>;
+                totalMatches: z.ZodOptional<z.ZodNumber>;
                 reportedTotalMatches: z.ZodOptional<z.ZodNumber>;
                 reachableTotalMatches: z.ZodOptional<z.ZodNumber>;
+                totalResults: z.ZodOptional<z.ZodNumber>;
+                itemsPerPage: z.ZodOptional<z.ZodNumber>;
                 totalMatchesKind: z.ZodOptional<z.ZodEnum<{
                     exact: "exact";
                     reported: "reported";
                     lowerBound: "lowerBound";
                 }>>;
                 totalMatchesCapped: z.ZodOptional<z.ZodBoolean>;
-                hasMore: z.ZodBoolean;
-                nextPage: z.ZodOptional<z.ZodNumber>;
                 uniqueFileCount: z.ZodOptional<z.ZodNumber>;
             }, z.core.$strip>>;
         }, z.core.$strip>;
@@ -80,6 +86,25 @@ export declare const GitHubCodeSearchOutputLocalSchema: z.ZodObject<{
         incompleteResults: z.ZodOptional<z.ZodLiteral<true>>;
     }, z.core.$strip>>>;
     warnings: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    diagnostics: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        level: z.ZodEnum<{
+            error: "error";
+            info: "info";
+            warning: "warning";
+        }>;
+        message: z.ZodString;
+        field: z.ZodOptional<z.ZodString>;
+        code: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>>;
+    next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        tool: z.ZodString;
+        query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+        why: z.ZodOptional<z.ZodString>;
+        confidence: z.ZodOptional<z.ZodEnum<{
+            exact: "exact";
+            heuristic: "heuristic";
+        }>>;
+    }, z.core.$strip>>>;
     errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
         id: z.ZodString;
         error: z.ZodString;

package/dist/tools/github_search_pull_requests/contentResponse/commentsShaping.d.ts

@@ -0,0 +1,68 @@
+import type { NormalizedPrContentRequest } from '../contentRequest.js';
+import { type QueryLike } from './pagination.js';
+export declare function shapeComments(pr: Record<string, unknown>, query: QueryLike, request: NormalizedPrContentRequest): {
+    comments?: undefined;
+    commentPagination?: undefined;
+} | {
+    comments: ({
+        createdAt: unknown;
+        updatedAt: unknown;
+        body: string;
+        bodyPagination: {
+            nextCharOffset?: number;
+            charOffset: number;
+            charLength: number;
+            totalChars: number;
+            hasMore: boolean;
+        };
+        in_reply_to_id?: unknown;
+        id: unknown;
+        author: unknown;
+        commentType: unknown;
+        path: unknown;
+        line: unknown;
+    } | {
+        createdAt: unknown;
+        updatedAt: unknown;
+        bodyPreview: string;
+        in_reply_to_id?: unknown;
+        id: unknown;
+        author: unknown;
+        commentType: unknown;
+        path: unknown;
+        line: unknown;
+    })[];
+    commentPagination: import("./pagination.js").Pagination;
+};
+export declare function shapeReviews(pr: Record<string, unknown>, query: QueryLike, request: NormalizedPrContentRequest): {
+    reviews?: undefined;
+} | {
+    reviews: {
+        submittedAt: unknown;
+        commitId: unknown;
+        body?: string;
+        bodyPagination?: {
+            nextCharOffset?: number;
+            charOffset: number;
+            charLength: number;
+            totalChars: number;
+            hasMore: boolean;
+        };
+        id: unknown;
+        user: unknown;
+        state: unknown;
+    }[];
+};
+export declare function shapeCommits(pr: Record<string, unknown>, query: QueryLike, request: NormalizedPrContentRequest): {
+    commits?: undefined;
+    commitPagination?: undefined;
+} | {
+    commits: {
+        files?: any[];
+        sha: unknown;
+        message: unknown;
+        author: unknown;
+        date: unknown;
+    }[];
+    commitPagination: import("./pagination.js").Pagination;
+};

package/dist/tools/github_search_pull_requests/contentResponse/fileSurfaces.d.ts

@@ -0,0 +1,52 @@
+import type { NormalizedPrContentRequest } from '../contentRequest.js';
+import { type QueryLike } from './pagination.js';
+export declare function filePathOf(change: Record<string, unknown>): string;
+export declare function shapeFileChange(change: Record<string, unknown>, includePatch: boolean): {
+    patch?: string;
+    path: string;
+    status: string;
+    additions: number;
+    deletions: number;
+};
+export declare function stripPatchComments(patch: string): string;
+export declare function shapeFileSurfaces(pr: Record<string, unknown>, query: QueryLike, request: NormalizedPrContentRequest, shouldMinify?: boolean): {
+    changedFiles: ({
+        patch?: string;
+        path: string;
+        status: string;
+        additions: number;
+        deletions: number;
+    } | {
+        patchPagination?: {
+            nextCharOffset?: number;
+            charOffset: number;
+            charLength: number;
+            totalChars: number;
+            hasMore: boolean;
+        };
+        patch: string;
+        diff: import("../../../index.js").DiffPreview;
+        path: string;
+        status: string;
+        additions: number;
+        deletions: number;
+    })[];
+    filePagination: import("./pagination.js").Pagination;
+    filePathsPreview?: undefined;
+    filePathsPagination?: undefined;
+} | {
+    changedFiles?: undefined;
+    filePagination?: undefined;
+    filePathsPreview?: undefined;
+    filePathsPagination?: undefined;
+} | {
+    filePathsPreview: string[];
+    filePathsPagination: {
+        nextFilePage?: number;
+        totalFiles: number;
+        filesPerPage: number;
+        hasMore: boolean;
+    };
+    changedFiles?: undefined;
+    filePagination?: undefined;
+};

package/dist/tools/github_search_pull_requests/contentResponse/nextCalls.d.ts

@@ -0,0 +1,17 @@
+import type { NormalizedPrContentRequest } from '../contentRequest.js';
+import { type QueryLike } from './pagination.js';
+export declare function nextCalls(query: QueryLike, prNumber: number, request: NormalizedPrContentRequest, firstChangedFilePath?: string): {
+    fullReview?: Record<string, unknown>;
+    getCommits?: Record<string, unknown>;
+    getReviews?: Record<string, unknown>;
+    getComments?: Record<string, unknown>;
+    getSelectedPatches?: Record<string, unknown>;
+    getAllPatches?: Record<string, unknown>;
+    getChangedFiles?: Record<string, unknown>;
+    getBody?: Record<string, unknown>;
+    target: {
+        owner: string;
+        repo: string;
+        prNumber: number;
+    };
+};

package/dist/tools/github_search_pull_requests/contentResponse/pagination.d.ts

@@ -0,0 +1,63 @@
+export type QueryLike = {
+    owner?: string;
+    repo?: string;
+    prNumber?: number;
+    page?: number;
+    filePage?: number;
+    commentPage?: number;
+    commitPage?: number;
+    itemsPerPage?: number;
+    charOffset?: number;
+    commentBodyOffset?: number;
+    charLength?: number;
+    matchString?: string;
+};
+export declare function matchStringNeedle(query: QueryLike): string | undefined;
+export declare function containsNeedle(value: unknown, needle: string): boolean;
+export type Pagination = {
+    currentPage: number;
+    totalPages: number;
+    itemsPerPage: number;
+    totalItems: number;
+    hasMore: boolean;
+    nextPage?: number;
+};
+export type TextPagination = {
+    charOffset: number;
+    charLength: number;
+    totalChars: number;
+    hasMore: boolean;
+    nextCharOffset?: number;
+};
+export type ContentPaginationEntry = Record<string, unknown> & {
+    hasMore: boolean;
+    nextQuery?: Record<string, unknown>;
+};
+export type ContentPagination = Partial<Record<'body' | 'changedFiles' | 'comments' | 'commentBody' | 'commits' | 'patches' | 'filePaths', ContentPaginationEntry>>;
+export declare function paginateItems<T>(items: T[], page?: number, itemsPerPage?: number): {
+    items: T[];
+    pagination: Pagination;
+};
+export declare function paginateText(value: string | undefined, charOffset?: number, charLength?: number): {
+    content: string;
+    pagination: {
+        nextCharOffset?: number;
+        charOffset: number;
+        charLength: number;
+        totalChars: number;
+        hasMore: boolean;
+    };
+};
+export declare function compactBody(value: unknown, max?: number): string | undefined;
+export declare function baseQuery(query: QueryLike, prNumber: number): {
+    owner: string;
+    repo: string;
+    prNumber: number;
+};
+export declare function compactQuery(value: Record<string, unknown>): Record<string, unknown>;
+export declare function continuationQuery(query: QueryLike, prNumber: number, patch: Record<string, unknown>): Record<string, unknown>;
+export declare function textContinuationQuery(query: QueryLike, prNumber: number, content: Record<string, unknown>, pagination: TextPagination, extra?: Record<string, unknown>): Record<string, unknown> | undefined;
+export declare function pageContinuationQuery(query: QueryLike, prNumber: number, content: Record<string, unknown>, pageKey: 'filePage' | 'commentPage' | 'commitPage', pagination: Pagination): Record<string, unknown> | undefined;
+export declare function isRecord(value: unknown): value is Record<string, unknown>;
+export declare function readPagination(value: unknown): Pagination | undefined;
+export declare function readTextPagination(value: unknown): TextPagination | undefined;

package/dist/tools/github_search_pull_requests/contentResponse.d.ts

@@ -1,17 +1,3 @@
 import type { NormalizedPrContentRequest } from './contentRequest.js';
-type QueryLike = {
-    owner?: string;
-    repo?: string;
-    prNumber?: number;
-    page?: number;
-    filePage?: number;
-    commentPage?: number;
-    commitPage?: number;
-    itemsPerPage?: number;
-    charOffset?: number;
-    commentBodyOffset?: number;
-    charLength?: number;
-    matchString?: string;
-};
+import { type QueryLike } from './contentResponse/pagination.js';
 export declare function shapePullRequestForContent(pr: Record<string, unknown>, query: QueryLike, request: NormalizedPrContentRequest, shouldMinify?: boolean, showContentMap?: boolean): Record<string, unknown>;
-export {};

package/dist/tools/github_search_pull_requests/execution/commitsMode.d.ts

@@ -0,0 +1,4 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { ProcessedBulkResult } from '../../../types/toolResults.js';
+import type { GitHubPullRequestSearchInput, GitHubPullRequestSearchQuery } from './types.js';
+export declare function handleCommitsMode(query: GitHubPullRequestSearchInput, parsedData: GitHubPullRequestSearchQuery | undefined, authInfo: AuthInfo | undefined): Promise<ProcessedBulkResult>;

package/dist/tools/github_search_pull_requests/execution/issuesMode.d.ts

@@ -0,0 +1,4 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { ProcessedBulkResult } from '../../../types/toolResults.js';
+import type { GitHubPullRequestSearchInput, GitHubPullRequestSearchQuery } from './types.js';
+export declare function handleIssuesMode(query: GitHubPullRequestSearchInput, parsedData: GitHubPullRequestSearchQuery | undefined, authInfo: AuthInfo | undefined): Promise<ProcessedBulkResult>;

package/dist/tools/github_search_pull_requests/execution/pullRequestsMode.d.ts

@@ -0,0 +1,4 @@
+import { createLazyProviderContext } from '../../providerExecution.js';
+import type { ProcessedBulkResult } from '../../../types/toolResults.js';
+import type { GitHubPullRequestSearchInput, GitHubPullRequestSearchQuery } from './types.js';
+export declare function handlePullRequestsMode(query: GitHubPullRequestSearchInput, parsedData: GitHubPullRequestSearchQuery | undefined, getProviderContext: ReturnType<typeof createLazyProviderContext>): Promise<ProcessedBulkResult>;

package/dist/tools/github_search_pull_requests/execution/releasesMode.d.ts

@@ -0,0 +1,4 @@
+import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { ProcessedBulkResult } from '../../../types/toolResults.js';
+import type { GitHubPullRequestSearchInput, GitHubPullRequestSearchQuery } from './types.js';
+export declare function handleReleasesMode(query: GitHubPullRequestSearchInput, parsedData: GitHubPullRequestSearchQuery | undefined, authInfo: AuthInfo | undefined): Promise<ProcessedBulkResult>;

package/dist/tools/github_search_pull_requests/execution/types.d.ts

@@ -0,0 +1,6 @@
+import type { z } from 'zod';
+import { GitHubPullRequestSearchQueryLocalSchema } from '../scheme.js';
+import type { WithOptionalMeta } from '../../../types/execution.js';
+export type GitHubPullRequestSearchQuery = z.infer<typeof GitHubPullRequestSearchQueryLocalSchema>;
+export type GitHubPullRequestSearchInput = z.input<typeof GitHubPullRequestSearchQueryLocalSchema>;
+export type PartialPRQuery = WithOptionalMeta<GitHubPullRequestSearchQuery>;

package/dist/tools/github_search_pull_requests/execution.d.ts

@@ -1,7 +1,4 @@
 import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
-import type { z } from 'zod';
-import { GitHubPullRequestSearchQueryLocalSchema } from './scheme.js';
 import type { ToolExecutionArgs } from '../../types/execution.js';
-type GitHubPullRequestSearchInput = z.input<typeof GitHubPullRequestSearchQueryLocalSchema>;
+import type { GitHubPullRequestSearchInput } from './execution/types.js';
 export declare function searchMultipleGitHubPullRequests(args: ToolExecutionArgs<GitHubPullRequestSearchInput>): Promise<CallToolResult>;
-export {};

package/dist/tools/github_search_pull_requests/scheme.d.ts

@@ -206,7 +206,6 @@ export declare const GitHubSearchPullRequestsOutputLocalSchema: z.ZodObject<{
         kind: z.ZodString;
     }, z.core.$loose>]>>>;
     error: z.ZodOptional<z.ZodString>;
-    hints: z.ZodOptional<z.ZodArray<z.ZodString>>;
     base: z.ZodOptional<z.ZodString>;
     shared: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodNumber, z.ZodBoolean]>>>;
     responsePagination: z.ZodOptional<z.ZodObject<{
@@ -222,7 +221,17 @@ export declare const GitHubSearchPullRequestsOutputLocalSchema: z.ZodObject<{
         id: z.ZodOptional<z.ZodString>;
         status: z.ZodOptional<z.ZodString>;
         data: z.ZodOptional<z.ZodObject<{
-            pull_requests: z.ZodOptional<z.ZodArray<z.ZodObject<{}, z.core.$loose>>>;
+            pull_requests: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{}, z.core.$loose>]>>>;
+            issues: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodObject<{}, z.core.$loose>]>>>;
+            next: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+                tool: z.ZodString;
+                query: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+                why: z.ZodOptional<z.ZodString>;
+                confidence: z.ZodOptional<z.ZodEnum<{
+                    exact: "exact";
+                    heuristic: "heuristic";
+                }>>;
+            }, z.core.$strip>>>;
         }, z.core.$loose>>;
     }, z.core.$loose>>>;
 }, z.core.$loose>;