@octocodeai/octocode-tools-core 18.1.2 → 18.2.0

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

@@ -0,0 +1,260 @@
+import { z } from 'zod';
+export type LocalTextResultView = 'paginated' | 'discovery' | 'detailed' | 'content' | 'files' | 'filesWithout' | 'countLines' | 'countMatches' | 'matchOnly';
+export declare function toLegacyTextQuery(query: Record<string, unknown>, resultView: LocalTextResultView): Record<string, unknown>;
+export declare const LocalSearchQuerySchema: z.ZodUnion<readonly [z.ZodObject<{
+    path: z.ZodString;
+    sort: z.ZodDefault<z.ZodEnum<{
+        path: "path";
+        created: "created";
+        relevance: "relevance";
+        matchCount: "matchCount";
+        modified: "modified";
+        accessed: "accessed";
+    }>>;
+    goal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    page: z.ZodDefault<z.ZodNumber>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    langType: z.ZodOptional<z.ZodString>;
+    contextLines: z.ZodOptional<z.ZodNumber>;
+    regex: z.ZodDefault<z.ZodEnum<{
+        fixed: "fixed";
+        smart: "smart";
+        perl: "perl";
+    }>>;
+    caseMode: z.ZodDefault<z.ZodEnum<{
+        smart: "smart";
+        sensitive: "sensitive";
+        insensitive: "insensitive";
+    }>>;
+    wholeWord: z.ZodOptional<z.ZodBoolean>;
+    invertMatch: z.ZodOptional<z.ZodBoolean>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludeDir: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    noIgnore: z.ZodOptional<z.ZodBoolean>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    matchContentLength: z.ZodDefault<z.ZodNumber>;
+    maxMatchesPerFile: z.ZodOptional<z.ZodNumber>;
+    maxFiles: z.ZodOptional<z.ZodNumber>;
+    multiline: z.ZodDefault<z.ZodEnum<{
+        off: "off";
+        on: "on";
+        dotall: "dotall";
+    }>>;
+    rankingProfile: z.ZodDefault<z.ZodEnum<{
+        typescript: "typescript";
+        auto: "auto";
+        javascript: "javascript";
+        rust: "rust";
+        python: "python";
+        go: "go";
+        java: "java";
+        scala: "scala";
+        markdown: "markdown";
+        json: "json";
+        yaml: "yaml";
+        generic: "generic";
+    }>>;
+    matchPage: z.ZodOptional<z.ZodNumber>;
+    operation: z.ZodLiteral<"text">;
+    searchText: z.ZodString;
+    resultView: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        files: "files";
+        paginated: "paginated";
+        discovery: "discovery";
+        detailed: "detailed";
+        filesWithout: "filesWithout";
+        countLines: "countLines";
+        countMatches: "countMatches";
+        matchOnly: "matchOnly";
+    }>>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    reverse: z.ZodOptional<z.ZodBoolean>;
+    unique: z.ZodDefault<z.ZodEnum<{
+        count: "count";
+        list: "list";
+        off: "off";
+    }>>;
+    matchWindow: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    path: z.ZodString;
+    sort: z.ZodDefault<z.ZodEnum<{
+        path: "path";
+        created: "created";
+        relevance: "relevance";
+        matchCount: "matchCount";
+        modified: "modified";
+        accessed: "accessed";
+    }>>;
+    goal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    page: z.ZodDefault<z.ZodNumber>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    langType: z.ZodOptional<z.ZodString>;
+    contextLines: z.ZodOptional<z.ZodNumber>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludeDir: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    noIgnore: z.ZodOptional<z.ZodBoolean>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    matchContentLength: z.ZodDefault<z.ZodNumber>;
+    maxMatchesPerFile: z.ZodOptional<z.ZodNumber>;
+    maxFiles: z.ZodOptional<z.ZodNumber>;
+    rankingProfile: z.ZodDefault<z.ZodEnum<{
+        typescript: "typescript";
+        auto: "auto";
+        javascript: "javascript";
+        rust: "rust";
+        python: "python";
+        go: "go";
+        java: "java";
+        scala: "scala";
+        markdown: "markdown";
+        json: "json";
+        yaml: "yaml";
+        generic: "generic";
+    }>>;
+    captureText: z.ZodOptional<z.ZodBoolean>;
+    matchPage: z.ZodOptional<z.ZodNumber>;
+    operation: z.ZodLiteral<"structural">;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    reverse: z.ZodOptional<z.ZodBoolean>;
+    pattern: z.ZodString;
+    resultView: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        files: "files";
+        countMatches: "countMatches";
+    }>>>;
+}, z.core.$strict>, z.ZodObject<{
+    path: z.ZodString;
+    sort: z.ZodDefault<z.ZodEnum<{
+        path: "path";
+        created: "created";
+        relevance: "relevance";
+        matchCount: "matchCount";
+        modified: "modified";
+        accessed: "accessed";
+    }>>;
+    goal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    page: z.ZodDefault<z.ZodNumber>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    include: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    langType: z.ZodOptional<z.ZodString>;
+    contextLines: z.ZodOptional<z.ZodNumber>;
+    exclude: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludeDir: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    noIgnore: z.ZodOptional<z.ZodBoolean>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    matchContentLength: z.ZodDefault<z.ZodNumber>;
+    maxMatchesPerFile: z.ZodOptional<z.ZodNumber>;
+    maxFiles: z.ZodOptional<z.ZodNumber>;
+    rankingProfile: z.ZodDefault<z.ZodEnum<{
+        typescript: "typescript";
+        auto: "auto";
+        javascript: "javascript";
+        rust: "rust";
+        python: "python";
+        go: "go";
+        java: "java";
+        scala: "scala";
+        markdown: "markdown";
+        json: "json";
+        yaml: "yaml";
+        generic: "generic";
+    }>>;
+    captureText: z.ZodOptional<z.ZodBoolean>;
+    matchPage: z.ZodOptional<z.ZodNumber>;
+    operation: z.ZodLiteral<"structural">;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+    reverse: z.ZodOptional<z.ZodBoolean>;
+    rule: z.ZodString;
+    resultView: z.ZodDefault<z.ZodOptional<z.ZodEnum<{
+        content: "content";
+        files: "files";
+        countMatches: "countMatches";
+    }>>>;
+}, z.core.$strict>, z.ZodObject<{
+    path: z.ZodString;
+    empty: z.ZodOptional<z.ZodBoolean>;
+    goal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    page: z.ZodDefault<z.ZodNumber>;
+    size: z.ZodOptional<z.ZodObject<{
+        greater: z.ZodOptional<z.ZodString>;
+        less: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    names: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludeDir: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    minDepth: z.ZodOptional<z.ZodNumber>;
+    pathPattern: z.ZodOptional<z.ZodString>;
+    time: z.ZodOptional<z.ZodObject<{
+        modifiedWithin: z.ZodOptional<z.ZodString>;
+        modifiedBefore: z.ZodOptional<z.ZodString>;
+        accessedWithin: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    entryType: z.ZodOptional<z.ZodEnum<{
+        f: "f";
+        d: "d";
+    }>>;
+    permissions: z.ZodOptional<z.ZodString>;
+    access: z.ZodOptional<z.ZodEnum<{
+        executable: "executable";
+        readable: "readable";
+        writable: "writable";
+    }>>;
+    detail: z.ZodDefault<z.ZodEnum<{
+        full: "full";
+        modified: "modified";
+        basic: "basic";
+    }>>;
+    operation: z.ZodLiteral<"files">;
+    pathRegex: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodDefault<z.ZodEnum<{
+        name: "name";
+        path: "path";
+        size: "size";
+        modified: "modified";
+    }>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>, z.ZodObject<{
+    path: z.ZodString;
+    reverse: z.ZodOptional<z.ZodBoolean>;
+    goal: z.ZodOptional<z.ZodString>;
+    reasoning: z.ZodOptional<z.ZodString>;
+    page: z.ZodDefault<z.ZodNumber>;
+    maxDepth: z.ZodOptional<z.ZodNumber>;
+    excludeDir: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    hidden: z.ZodOptional<z.ZodBoolean>;
+    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    entryType: z.ZodOptional<z.ZodEnum<{
+        f: "f";
+        d: "d";
+    }>>;
+    detail: z.ZodDefault<z.ZodEnum<{
+        full: "full";
+        modified: "modified";
+        basic: "basic";
+    }>>;
+    operation: z.ZodLiteral<"tree">;
+    namePattern: z.ZodOptional<z.ZodString>;
+    limit: z.ZodOptional<z.ZodNumber>;
+    sort: z.ZodDefault<z.ZodEnum<{
+        name: "name";
+        extension: "extension";
+        size: "size";
+        time: "time";
+    }>>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
+}, z.core.$strict>]>;
+export type LocalSearchQuery = z.infer<typeof LocalSearchQuerySchema>;
+export declare const LocalSearchBulkQuerySchema: z.ZodObject<{
+    responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
+    responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
+    queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
+}, z.core.$strict>;

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

@@ -1,4 +1,4 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/server';
 import { type ViewStructureQuery } from './scheme.js';
 import type { ToolExecutionArgs } from '../../types/execution.js';
 export declare function executeViewStructure(args: ToolExecutionArgs<ViewStructureQuery>): Promise<CallToolResult>;

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

@@ -10,9 +10,9 @@ export declare const LocalViewStructureQuerySchema: z.ZodObject<{
     }>>;
     hidden: z.ZodOptional<z.ZodBoolean>;
     sortBy: z.ZodDefault<z.ZodEnum<{
+        name: "name";
         extension: "extension";
         size: "size";
-        name: "name";
         time: "time";
     }>>;
     reverse: z.ZodOptional<z.ZodBoolean>;
@@ -23,13 +23,12 @@ export declare const LocalViewStructureQuerySchema: z.ZodObject<{
     }>>;
     recursive: z.ZodOptional<z.ZodBoolean>;
     extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    excludeDir: z.ZodOptional<z.ZodArray<z.ZodString>>;
     maxDepth: z.ZodOptional<z.ZodNumber>;
     limit: z.ZodOptional<z.ZodNumber>;
     page: z.ZodDefault<z.ZodNumber>;
     itemsPerPage: z.ZodOptional<z.ZodNumber>;
-    id: z.ZodOptional<z.ZodString>;
-    mainResearchGoal: z.ZodOptional<z.ZodString>;
-    researchGoal: z.ZodOptional<z.ZodString>;
+    goal: z.ZodOptional<z.ZodString>;
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export type ViewStructureQuery = z.infer<typeof LocalViewStructureQuerySchema>;
@@ -37,7 +36,7 @@ export declare const LocalViewStructureBulkQuerySchema: z.ZodObject<{
     responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export interface LocalViewStructureEntry {
     name?: string;
     type: 'file' | 'dir' | 'directory' | 'link' | 'symlink';
@@ -59,5 +58,9 @@ export interface LocalViewStructureData {
     summary?: string | Record<string, unknown>;
     pagination?: LocalItemPagination;
     next?: Record<string, ToolContinuation>;
+    terminalLimit?: boolean;
+    truncated?: boolean;
+    partialReasons?: Array<'limit' | 'walkLimit'>;
+    totalAvailable?: number;
 }
 export type LocalViewStructureOutput = BulkToolOutput<LocalViewStructureData>;

package/dist/tools/local_view_structure/viewStructureNext.d.ts

@@ -1,6 +1,6 @@
 import type { DirectoryEntry } from './structureFilters.js';
 type ViewStructureNextCall = {
-    tool: 'localGetFileContent' | 'localViewStructure';
+    tool: 'localGetFileContent' | 'local.tree';
     query: Record<string, unknown>;
     why: string;
     confidence?: 'exact' | 'high' | 'medium' | 'low';
@@ -10,7 +10,7 @@ export type ViewStructureNextMap = {
     viewDeeper?: ViewStructureNextCall;
 };
 /**
- * Build per-result continuation hints for a localViewStructure response: read
+ * Build per-result continuation hints for a local tree response: read
  * the first listed file, and/or descend into the first listed subdirectory.
  * `nextPage` (pagination) is added separately by the caller.
  *
@@ -19,7 +19,7 @@ export type ViewStructureNextMap = {
  * SKIP_TRAVERSAL_KEYS in utils/response/pathRelativize.ts), so hints stay
  * directly callable with no manual path conversion. Meta-free by construction:
  * queries are built from the entry path alone, never spread from the caller
- * query, so no auto-filled id/researchGoal/reasoning can leak in.
+ * query, so no auto-filled goal/reasoning can leak in.
  */
 export declare function buildViewStructureNextMap(entries: readonly DirectoryEntry[]): ViewStructureNextMap | undefined;
 export {};

package/dist/tools/lsp/semantic_content/execution.d.ts

@@ -1,4 +1,4 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/server';
 import type { ToolExecutionArgs } from '../../../types/execution.js';
 import { type LspGetSemanticsQuery } from '../shared/semanticTypes.js';
 export declare function executeLspGetSemantics(args: ToolExecutionArgs<LspGetSemanticsQuery>): Promise<CallToolResult>;

package/dist/tools/lsp/semantic_content/scheme.d.ts

@@ -1,55 +1,19 @@
 import { z } from 'zod';
 import type { ItemPagination, ToolContinuation } from '../../../scheme/pagination.js';
 import type { BulkToolOutput } from '../../../types/toolOutput.js';
-export declare const LspGetSemanticsQueryDisplaySchema: z.ZodObject<{
+export declare const LspGetSemanticsQuerySchema: z.ZodObject<{
     uri: z.ZodOptional<z.ZodString>;
     type: z.ZodDefault<z.ZodEnum<{
         definition: "definition";
-        references: "references";
-        callers: "callers";
-        callees: "callees";
-        callHierarchy: "callHierarchy";
-        hover: "hover";
         documentSymbols: "documentSymbols";
-        typeDefinition: "typeDefinition";
-        implementation: "implementation";
         workspaceSymbol: "workspaceSymbol";
-        supertypes: "supertypes";
-        subtypes: "subtypes";
-        diagnostic: "diagnostic";
-    }>>;
-    symbolName: z.ZodOptional<z.ZodString>;
-    lineHint: z.ZodOptional<z.ZodNumber>;
-    orderHint: z.ZodDefault<z.ZodNumber>;
-    depth: z.ZodOptional<z.ZodNumber>;
-    includeDeclaration: z.ZodDefault<z.ZodBoolean>;
-    groupByFile: z.ZodOptional<z.ZodBoolean>;
-    page: z.ZodDefault<z.ZodNumber>;
-    itemsPerPage: z.ZodOptional<z.ZodNumber>;
-    contextLines: z.ZodOptional<z.ZodNumber>;
-    format: z.ZodDefault<z.ZodEnum<{
-        structured: "structured";
-        compact: "compact";
-    }>>;
-    workspaceRoot: z.ZodOptional<z.ZodString>;
-    id: z.ZodOptional<z.ZodString>;
-    mainResearchGoal: z.ZodOptional<z.ZodString>;
-    researchGoal: z.ZodOptional<z.ZodString>;
-    reasoning: z.ZodOptional<z.ZodString>;
-}, z.core.$strip>;
-export declare const LspGetSemanticsQuerySchema: z.ZodObject<{
-    uri: z.ZodOptional<z.ZodString>;
-    type: z.ZodDefault<z.ZodEnum<{
-        definition: "definition";
         references: "references";
         callers: "callers";
         callees: "callees";
         callHierarchy: "callHierarchy";
         hover: "hover";
-        documentSymbols: "documentSymbols";
         typeDefinition: "typeDefinition";
         implementation: "implementation";
-        workspaceSymbol: "workspaceSymbol";
         supertypes: "supertypes";
         subtypes: "subtypes";
         diagnostic: "diagnostic";
@@ -61,23 +25,21 @@ export declare const LspGetSemanticsQuerySchema: z.ZodObject<{
     includeDeclaration: z.ZodDefault<z.ZodBoolean>;
     groupByFile: z.ZodOptional<z.ZodBoolean>;
     page: z.ZodDefault<z.ZodNumber>;
-    itemsPerPage: z.ZodOptional<z.ZodNumber>;
+    pageSize: z.ZodOptional<z.ZodNumber>;
     contextLines: z.ZodOptional<z.ZodNumber>;
     format: z.ZodDefault<z.ZodEnum<{
         structured: "structured";
         compact: "compact";
     }>>;
     workspaceRoot: z.ZodOptional<z.ZodString>;
-    id: z.ZodOptional<z.ZodString>;
-    mainResearchGoal: z.ZodOptional<z.ZodString>;
-    researchGoal: z.ZodOptional<z.ZodString>;
+    goal: z.ZodOptional<z.ZodString>;
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const BulkLspGetSemanticsQuerySchema: z.ZodObject<{
     responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 interface LspLocation {
     uri: string;
     absolutePath?: string;

package/dist/tools/lsp/semantic_content/semanticEnvelopes/envelopeHelpers.d.ts

@@ -8,7 +8,7 @@ export type PaginationInfo = {
     totalPages: number;
     totalResults: number;
     hasMore: boolean;
-    itemsPerPage: number;
+    pageSize: number;
     nextPage?: number;
 };
 export declare function emptyCategoryForReason(type: SemanticContentType, reason: string): SemanticEmptyCategory;

package/dist/tools/lsp/semantic_content/semanticFileOps/anchor.d.ts

@@ -30,7 +30,7 @@ export declare function nativeDocumentSymbols(uri: string, content: string): unk
  * extractor (`extractJsSymbols`) declines — notably Flow-typed `.js` (Flow
  * syntax like type annotations/generics can make oxc's default JS grammar
  * fail the whole-file parse, returning an empty body). `extractGraphFacts`
- * uses a more lenient extraction already proven elsewhere (localFindDeadCode)
+ * uses a more lenient extraction already proven elsewhere (localAnalyzeGraph)
  * to tolerate this exact file class, and its declarations already carry
  * 0-based LSP `range`s — so they slot into the same DocumentSymbol shape
  * `nativeDocumentSymbols` produces, just without a full symbol hierarchy

package/dist/tools/lsp/semantic_content/semanticPresentation.d.ts

@@ -21,7 +21,6 @@ export type CompactCall = {
 };
 export declare function attachSemanticRawEvidence<T extends object>(result: T): T;
 export declare function formatSemanticResult(query: LspGetSemanticsQuery, result: LspSemanticEnvelope | Record<string, unknown>): LspSemanticEnvelope | Record<string, unknown>;
-export { withSemanticNext } from './semanticNext.js';
 export declare function isSemanticEnvelope(value: LspSemanticEnvelope | Record<string, unknown>): value is LspSemanticEnvelope;
 export declare function compactSemanticEnvelope(envelope: LspSemanticEnvelope): LspSemanticEnvelope;
 export declare function compactSemanticPayload(payload: LspSemanticEnvelope['payload']): LspSemanticEnvelope['payload'];

package/dist/tools/lsp/shared/semanticTypes.d.ts

@@ -9,11 +9,10 @@ export type SemanticQueryBase = {
     uri?: string;
     workspaceRoot?: string;
     page?: number;
-    itemsPerPage?: number;
+    pageSize?: number;
     contextLines?: number;
     format?: SemanticOutputFormat;
-    mainResearchGoal?: string;
-    researchGoal?: string;
+    goal?: string;
     reasoning?: string;
 };
 export type SymbolAnchoredSemanticQuery = SemanticQueryBase & {
@@ -86,6 +85,7 @@ export type SemanticEmptyState = {
 export type LspSemanticEnvelope = {
     type: SemanticContentType;
     uri: string;
+    workspaceRoot?: string;
     format?: SemanticOutputFormat;
     resolvedSymbol?: CompactResolvedSymbol;
     lsp: {
@@ -174,6 +174,9 @@ export type LspSemanticEnvelope = {
     pagination?: unknown;
     warnings?: string[];
     hints?: string[];
+    terminalLimit?: boolean;
+    truncated?: boolean;
+    partialReasons?: Array<'warmupCap' | 'depth' | 'budget'>;
     next?: Record<string, {
         tool: string;
         query: Record<string, unknown>;

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

@@ -1,10 +1,13 @@
-import { type CallToolResult } from '@modelcontextprotocol/sdk/types.js';
+import type { CallToolResult } from '@modelcontextprotocol/server';
 import type { z } from 'zod';
-import type { NpmPackageQuerySchema } from '@octocodeai/octocode-core/schemas';
-type NpmSearchQuery = z.input<typeof NpmPackageQuerySchema>;
+import type { NpmSearchQueryLocalSchema } from './scheme.js';
+type NpmSearchQuery = z.input<typeof NpmSearchQueryLocalSchema> & {
+    pageSize?: number;
+};
 export { foldKeywords, isPackageNotFoundError } from './queryHelpers.js';
 import type { PackageResult } from '../../utils/package/common.js';
 import type { ToolExecutionArgs } from '../../types/execution.js';
+export { buildPackagePagination } from './pagination.js';
 /**
  * Normalize the many repository URL shapes npm packages carry
  * (ssh://git@…, git+https://…, git://…, git@host:owner/repo, and npm's
@@ -38,14 +41,4 @@ type CompactPackageData = {
 };
 export declare function formatPackageData(pkg: PackageResult): PackageData;
 export declare function compactPackageRepositories(packages: PackageData[]): CompactPackageData;
-type PackagePagination = {
-    currentPage: number;
-    totalPages: number;
-    perPage: number;
-    totalFound: number;
-    returned: number;
-    hasMore: boolean;
-    nextPage?: number;
-};
-export declare function buildPackagePagination(query: NpmSearchQuery, totalFound: number, returned: number, isKeyword: boolean): PackagePagination;
 export declare function searchPackages(args: ToolExecutionArgs<NpmSearchQuery>): Promise<CallToolResult>;

package/dist/tools/package_search/pagination.d.ts

@@ -0,0 +1,21 @@
+type PackagePageQuery = {
+    keywords?: string[];
+    page?: number;
+    pageSize?: number;
+};
+export type PackagePagination = {
+    currentPage: number;
+    totalPages: number;
+    perPage: number;
+    totalFound: number;
+    returned: number;
+    hasMore: boolean;
+    nextPage?: number;
+    continuationUnavailable?: {
+        reason: 'schemaPageLimit';
+        maxPage: number;
+    };
+};
+export declare function buildPackagePagination(query: PackagePageQuery, totalFound: number, returned: number, isKeyword: boolean): PackagePagination;
+export declare function buildPackagePageContinuation(query: PackagePageQuery, pagination: PackagePagination): Record<string, unknown> | undefined;
+export {};

package/dist/tools/package_search/queryHelpers.d.ts

@@ -1,8 +1,6 @@
 /**
- * Fold a `keywords` field (string as-is, or an array joined with spaces) into a
- * single registry query string. Sibling tools (ghSearchCode/localSearchCode)
- * take keyword arrays, so agents pass arrays here too — the scheme accepts both
- * shapes and this is where the array is collapsed. Returns undefined when empty.
+ * Fold keyword terms into one registry query string. Returns undefined when
+ * the list is absent or empty.
  */
-export declare function foldKeywords(keywords: string | string[] | undefined): string | undefined;
+export declare function foldKeywords(keywords: string[] | undefined): string | undefined;
 export declare function isPackageNotFoundError(message: string): boolean;

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

@@ -2,19 +2,17 @@ import { z } from 'zod';
 import type { ItemPagination, ToolContinuation } from '../../scheme/pagination.js';
 import type { BulkToolOutput } from '../../types/toolOutput.js';
 export declare const NpmSearchQueryLocalSchema: z.ZodObject<{
-    packageName: z.ZodString;
-    keywords: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>;
+    packageName: z.ZodOptional<z.ZodString>;
+    keywords: z.ZodOptional<z.ZodArray<z.ZodString>>;
     page: z.ZodDefault<z.ZodNumber>;
-    id: z.ZodOptional<z.ZodString>;
-    mainResearchGoal: z.ZodOptional<z.ZodString>;
-    researchGoal: z.ZodOptional<z.ZodString>;
+    goal: z.ZodOptional<z.ZodString>;
     reasoning: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 export declare const NpmSearchBulkQueryLocalSchema: z.ZodObject<{
     responseCharOffset: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     responseCharLength: z.ZodOptional<z.ZodPreprocess<z.ZodNumber>>;
     queries: z.ZodArray<z.ZodType<unknown, unknown, z.core.$ZodTypeInternals<unknown, unknown>>>;
-}, z.core.$strip>;
+}, z.core.$strict>;
 export interface NpmSearchPackage {
     name: string;
     version?: string;
@@ -35,10 +33,17 @@ export interface NpmSearchRepository {
     next: Record<string, ToolContinuation>;
     [key: string]: unknown;
 }
+export type NpmSearchPagination = ItemPagination & {
+    continuationUnavailable?: {
+        reason: 'schemaPageLimit';
+        maxPage: number;
+    };
+};
 export interface NpmSearchData {
     packages?: NpmSearchPackage[];
     repositories?: Record<string, NpmSearchRepository>;
-    pagination?: ItemPagination;
+    pagination?: NpmSearchPagination;
+    next?: Record<string, ToolContinuation>;
     [key: string]: unknown;
 }
 export type NpmSearchOutputLocal = BulkToolOutput<NpmSearchData>;

package/dist/tools/providerExecution.d.ts

@@ -1,7 +1,7 @@
-import type { AuthInfo } from '@modelcontextprotocol/sdk/server/auth/types.js';
+import type { AuthInfo } from '@modelcontextprotocol/server';
 import type { ProcessedBulkResult } from '../types/toolResults.js';
 import { type ICodeHostProvider, type ProviderCapabilities, type ProviderResponse, type ProviderType } from '../providers/types.js';
-interface ProviderExecutionContext {
+export interface ProviderExecutionContext {
     providerType: ProviderType;
     provider: ICodeHostProvider;
     capabilities: ProviderCapabilities;
@@ -32,8 +32,7 @@ export declare function createProviderExecutionContext(authInfo?: AuthInfo): Pro
 export declare function createLazyProviderContext(authInfo?: AuthInfo): () => ProviderExecutionContext;
 export declare function providerSupports(context: Pick<ProviderExecutionContext, 'capabilities'>, capability: keyof ProviderCapabilities): boolean;
 export declare function executeProviderOperation<TQuery extends {
-    mainResearchGoal?: string;
-    researchGoal?: string;
+    goal?: string;
     reasoning?: string;
 }, TData>(query: TQuery, operation: () => Promise<ProviderResponse<TData>>): Promise<{
     ok: true;

package/dist/tools/providerMappers/codeSearch.d.ts

@@ -1,6 +1,6 @@
 import type { CodeSearchResult } from '../../providers/types.js';
 import type { z } from 'zod';
-import type { GitHubCodeSearchQuerySchema } from '@octocodeai/octocode-core/schemas';
+import type { GitHubCodeSearchQuerySchema } from '../../toolContract/schemas.js';
 import type { WithOptionalMeta } from '../../types/execution.js';
 type GitHubCodeSearchQuery = z.infer<typeof GitHubCodeSearchQuerySchema>;
 /**
@@ -21,8 +21,7 @@ export declare function mapCodeSearchToolQuery(query: WithOptionalMeta<GitHubCod
     match: "file" | "path";
     limit: number | undefined;
     page: number;
-    mainResearchGoal: string;
-    researchGoal: string;
+    goal: string;
     reasoning: string;
 };
 export interface CodeSearchGroupedMatch {
@@ -37,7 +36,7 @@ export interface CodeSearchGroupedMatch {
 }
 export interface CodeSearchGroupedResult {
     id: string;
-    queryId?: string;
+    queryIndex?: number;
     owner: string;
     repo: string;
     matches: CodeSearchGroupedMatch[];

package/dist/tools/providerMappers/fileContent.d.ts

@@ -20,8 +20,7 @@ export declare function mapFileContentToolQuery(query: LocalFileContentQuery): {
     minify: "none" | "standard" | "symbols";
     matchStringIsRegex: boolean;
     matchStringCaseSensitive: boolean;
-    mainResearchGoal: string;
-    researchGoal: string;
+    goal: string;
     reasoning: string;
 };
 export declare function mapFileContentProviderResult(data: ProviderFileContentResult, query: WithOptionalMeta<LocalFileContentQuery>): Record<string, unknown>;