@cyanheads/brapi-mcp-server 0.6.4 → 0.7.0

package/dist/mcp-server/tools/definitions/index.d.ts

@@ -230,6 +230,65 @@ export declare const readOnlyToolDefinitions: (import("@cyanheads/mcp-ts-core").
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
     readonly when: "Upstream returned no study record for the requested DbId";
     readonly recovery: "Verify the studyDbId on the target server, or run brapi_find_studies to discover valid IDs.";
+}], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    alias: import("zod").ZodOptional<import("zod").ZodString>;
+    studies: import("zod").ZodArray<import("zod").ZodString>;
+    variables: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    germplasm: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    shape: import("zod").ZodDefault<import("zod").ZodEnum<{
+        wide: "wide";
+        long: "long";
+    }>>;
+    aggregate: import("zod").ZodDefault<import("zod").ZodEnum<{
+        all: "all";
+        mean: "mean";
+        median: "median";
+        first: "first";
+    }>>;
+    loadLimit: import("zod").ZodOptional<import("zod").ZodNumber>;
+    extraFilters: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    alias: import("zod").ZodString;
+    studies: import("zod").ZodArray<import("zod").ZodString>;
+    shape: import("zod").ZodEnum<{
+        wide: "wide";
+        long: "long";
+    }>;
+    aggregate: import("zod").ZodEnum<{
+        all: "all";
+        mean: "mean";
+        median: "median";
+        first: "first";
+    }>;
+    observationCount: import("zod").ZodNumber;
+    germplasmCount: import("zod").ZodNumber;
+    variableCount: import("zod").ZodNumber;
+    variableLegend: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    dataframe: import("zod").ZodOptional<import("zod").ZodObject<{
+        tableName: import("zod").ZodString;
+        rowCount: import("zod").ZodNumber;
+        columns: import("zod").ZodArray<import("zod").ZodString>;
+        createdAt: import("zod").ZodString;
+        expiresAt: import("zod").ZodString;
+        truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        maxRows: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    warnings: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "unknown_alias";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "No connection has been registered under the requested alias";
+    readonly recovery: "Run brapi_connect with this alias (or omit `alias` to use the default connection) before calling brapi_build_phenotype_matrix.";
+}, {
+    readonly reason: "all_filters_dropped";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "The active dialect dropped every filter supplied — the call would silently widen to the unfiltered baseline";
+    readonly recovery: "Drop unsupported filters or use studies / germplasm / variables to scope the query to supported filter paths on the active dialect.";
+}, {
+    readonly reason: "no_observation_path";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ServiceUnavailable;
+    readonly when: "Neither /observations nor /observationunits returned data for any requested study after probing both paths";
+    readonly recovery: "Verify the studyDbIds exist and the BrAPI server exposes /observations or /observationunits. Use brapi_server_info to inspect the capability list.";
 }], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     baseUrl: import("zod").ZodOptional<import("zod").ZodString>;
     auth: import("zod").ZodOptional<import("zod").ZodDiscriminatedUnion<[import("zod").ZodObject<{
@@ -363,6 +422,61 @@ export declare const readOnlyToolDefinitions: (import("@cyanheads/mcp-ts-core").
     readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
     readonly when: "SQL violated read-only rules (multi-statement, non-SELECT, or disallowed operation)";
     readonly recovery: "Submit a single SELECT statement using only registered dataframes. For changes, use `registerAs` in this tool to materialize a result, or brapi_dataframe_drop to remove a dataframe.";
+}], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    alias: import("zod").ZodOptional<import("zod").ZodString>;
+    germplasmDbIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    variantSetDbId: import("zod").ZodString;
+    format: import("zod").ZodEnum<{
+        plink: "plink";
+        "vcf-lite": "vcf-lite";
+        "matrix-json": "matrix-json";
+    }>;
+    maxCalls: import("zod").ZodOptional<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    alias: import("zod").ZodString;
+    format: import("zod").ZodEnum<{
+        plink: "plink";
+        "vcf-lite": "vcf-lite";
+        "matrix-json": "matrix-json";
+    }>;
+    rowCount: import("zod").ZodNumber;
+    columnCount: import("zod").ZodNumber;
+    variantColumnLegend: import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>;
+    callFormatting: import("zod").ZodObject<{
+        expandHomozygotes: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodBoolean>>;
+        unknownString: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        sepPhased: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+        sepUnphased: import("zod").ZodOptional<import("zod").ZodNullable<import("zod").ZodString>>;
+    }, import("zod/v4/core").$strip>;
+    dataframe: import("zod").ZodObject<{
+        tableName: import("zod").ZodString;
+        rowCount: import("zod").ZodNumber;
+        columns: import("zod").ZodArray<import("zod").ZodString>;
+        createdAt: import("zod").ZodString;
+        expiresAt: import("zod").ZodString;
+        truncated: import("zod").ZodOptional<import("zod").ZodBoolean>;
+        maxRows: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>;
+    vcf: import("zod").ZodOptional<import("zod").ZodString>;
+    ped: import("zod").ZodOptional<import("zod").ZodString>;
+    map: import("zod").ZodOptional<import("zod").ZodString>;
+    truncated: import("zod").ZodBoolean;
+    warnings: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "unknown_alias";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "No connection has been registered under the requested alias";
+    readonly recovery: "Run brapi_connect with this alias (or omit `alias` to use the default connection) before calling brapi_export_genotype_matrix.";
+}, {
+    readonly reason: "no_filters";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "No variantSetDbId was provided";
+    readonly recovery: "Provide variantSetDbId before retrying — unfiltered genotype-call pulls are too expensive.";
+}, {
+    readonly reason: "search_endpoint_disabled";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.ValidationError;
+    readonly when: "The active dialect declares POST /search/calls as known-dead on this server";
+    readonly recovery: "Connect to a different BrAPI server that exposes a working /search/calls route — genotype-call workflows are not viable here.";
 }], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     alias: import("zod").ZodOptional<import("zod").ZodString>;
     variantSetDbId: import("zod").ZodOptional<import("zod").ZodString>;
@@ -919,6 +1033,40 @@ export declare const readOnlyToolDefinitions: (import("@cyanheads/mcp-ts-core").
     readonly notice: import("zod").ZodOptional<import("zod").ZodString>;
     readonly warnings: import("zod").ZodArray<import("zod").ZodString>;
 }> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
+    alias: import("zod").ZodOptional<import("zod").ZodString>;
+    germplasmDbId: import("zod").ZodString;
+    variables: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+}, import("zod/v4/core").$strip>, import("zod").ZodObject<{
+    alias: import("zod").ZodString;
+    germplasmDbId: import("zod").ZodString;
+    germplasmName: import("zod").ZodOptional<import("zod").ZodString>;
+    studyCount: import("zod").ZodNumber;
+    studyDbIds: import("zod").ZodArray<import("zod").ZodString>;
+    perVariable: import("zod").ZodArray<import("zod").ZodObject<{
+        observationVariableDbId: import("zod").ZodString;
+        observationVariableName: import("zod").ZodOptional<import("zod").ZodString>;
+        n: import("zod").ZodNumber;
+        mean: import("zod").ZodOptional<import("zod").ZodNumber>;
+        median: import("zod").ZodOptional<import("zod").ZodNumber>;
+        sd: import("zod").ZodOptional<import("zod").ZodNumber>;
+        min: import("zod").ZodOptional<import("zod").ZodString>;
+        max: import("zod").ZodOptional<import("zod").ZodString>;
+        studyCount: import("zod").ZodNumber;
+        studyDbIds: import("zod").ZodArray<import("zod").ZodString>;
+        seasons: import("zod").ZodArray<import("zod").ZodString>;
+    }, import("zod/v4/core").$strip>>;
+    warnings: import("zod").ZodArray<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>, readonly [{
+    readonly reason: "unknown_alias";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "No connection has been registered under the requested alias";
+    readonly recovery: "Run brapi_connect with this alias (or omit `alias` to use the default connection) before calling brapi_germplasm_performance.";
+}, {
+    readonly reason: "germplasm_not_found";
+    readonly code: import("@cyanheads/mcp-ts-core/errors").JsonRpcErrorCode.NotFound;
+    readonly when: "Upstream returned no germplasm record for the requested germplasmDbId";
+    readonly recovery: "Verify the germplasmDbId on the target server, or run brapi_find_germplasm to discover valid IDs.";
+}], undefined> | import("@cyanheads/mcp-ts-core").ToolDefinition<import("zod").ZodObject<{
     imageDbIds: import("zod").ZodArray<import("zod").ZodString>;
     alias: import("zod").ZodOptional<import("zod").ZodString>;
 }, import("zod/v4/core").$strip>, import("zod").ZodObject<{

package/dist/mcp-server/tools/definitions/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAyBH;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoBnC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;yDAAuB,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAyB,CAAC;AAE5D,qEAAqE;AACrE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AA4BH;;;;GAIG;AACH,eAAO,MAAM,uBAAuB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAuBnC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,mBAAmB;;;;;yDAAuB,CAAC;AAExD;;;;GAIG;AACH,eAAO,MAAM,qBAAqB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAAyB,CAAC;AAE5D,qEAAqE;AACrE,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAA4B,CAAC"}

package/dist/mcp-server/tools/definitions/index.js

@@ -10,12 +10,14 @@
  *
  * @module mcp-server/tools/definitions/index
  */
+import { brapiBuildPhenotypeMatrix } from './brapi-build-phenotype-matrix.tool.js';
 import { brapiConnect } from './brapi-connect.tool.js';
 import { brapiDataframeDescribe } from './brapi-dataframe-describe.tool.js';
 import { brapiDataframeDrop } from './brapi-dataframe-drop.tool.js';
 import { brapiDataframeExport } from './brapi-dataframe-export.tool.js';
 import { brapiDataframeQuery } from './brapi-dataframe-query.tool.js';
 import { brapiDescribeFilters } from './brapi-describe-filters.tool.js';
+import { brapiExportGenotypeMatrix } from './brapi-export-genotype-matrix.tool.js';
 import { brapiFindGenotypeCalls } from './brapi-find-genotype-calls.tool.js';
 import { brapiFindGermplasm } from './brapi-find-germplasm.tool.js';
 import { brapiFindImages } from './brapi-find-images.tool.js';
@@ -24,6 +26,7 @@ import { brapiFindObservations } from './brapi-find-observations.tool.js';
 import { brapiFindStudies } from './brapi-find-studies.tool.js';
 import { brapiFindVariables } from './brapi-find-variables.tool.js';
 import { brapiFindVariants } from './brapi-find-variants.tool.js';
+import { brapiGermplasmPerformance } from './brapi-germplasm-performance.tool.js';
 import { brapiGetGermplasm } from './brapi-get-germplasm.tool.js';
 import { brapiGetImage } from './brapi-get-image.tool.js';
 import { brapiGetStudy } from './brapi-get-study.tool.js';
@@ -39,6 +42,7 @@ import { brapiWalkPedigree } from './brapi-walk-pedigree.tool.js';
  */
 export const readOnlyToolDefinitions = [
     brapiConnect,
+    brapiBuildPhenotypeMatrix,
     brapiServerInfo,
     brapiDescribeFilters,
     brapiFindStudies,
@@ -46,6 +50,7 @@ export const readOnlyToolDefinitions = [
     brapiFindGermplasm,
     brapiGetGermplasm,
     brapiWalkPedigree,
+    brapiGermplasmPerformance,
     brapiFindVariables,
     brapiFindObservations,
     brapiFindImages,
@@ -53,6 +58,7 @@ export const readOnlyToolDefinitions = [
     brapiFindLocations,
     brapiFindVariants,
     brapiFindGenotypeCalls,
+    brapiExportGenotypeMatrix,
     brapiDataframeDescribe,
     brapiDataframeQuery,
     brapiRawGet,

package/dist/mcp-server/tools/definitions/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAElE;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,YAAY;IACZ,eAAe;IACf,oBAAoB;IACpB,gBAAgB;IAChB,aAAa;IACb,kBAAkB;IAClB,iBAAiB;IACjB,iBAAiB;IACjB,kBAAkB;IAClB,qBAAqB;IACrB,eAAe;IACf,aAAa;IACb,kBAAkB;IAClB,iBAAiB;IACjB,sBAAsB;IACtB,sBAAsB;IACtB,mBAAmB;IACnB,WAAW;IACX,cAAc;CACf,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,kBAAkB,CAAC,CAAC;AAExD;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,oBAAoB,CAAC,CAAC;AAE5D,qEAAqE;AACrE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,uBAAuB,CAAC,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/definitions/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,sBAAsB,EAAE,MAAM,oCAAoC,CAAC;AAC5E,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,iCAAiC,CAAC;AACtE,OAAO,EAAE,oBAAoB,EAAE,MAAM,kCAAkC,CAAC;AACxE,OAAO,EAAE,yBAAyB,EAAE,MAAM,wCAAwC,CAAC;AACnF,OAAO,EAAE,sBAAsB,EAAE,MAAM,qCAAqC,CAAC;AAC7E,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,qBAAqB,EAAE,MAAM,mCAAmC,CAAC;AAC1E,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,yBAAyB,EAAE,MAAM,uCAAuC,CAAC;AAClF,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAClE,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAC1D,OAAO,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAC;AACtD,OAAO,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,uBAAuB,EAAE,MAAM,qCAAqC,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,+BAA+B,CAAC;AAElE;;;;GAIG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAG;IACrC,YAAY;IACZ,yBAAyB;IACzB,eAAe;IACf,oBAAoB;IACpB,gBAAgB;IAChB,aAAa;IACb,kBAAkB;IAClB,iBAAiB;IACjB,iBAAiB;IACjB,yBAAyB;IACzB,kBAAkB;IAClB,qBAAqB;IACrB,eAAe;IACf,aAAa;IACb,kBAAkB;IAClB,iBAAiB;IACjB,sBAAsB;IACtB,yBAAyB;IACzB,sBAAsB;IACtB,mBAAmB;IACnB,WAAW;IACX,cAAc;CACf,CAAC;AAEF;;;;;GAKG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,CAAC,kBAAkB,CAAC,CAAC;AAExD;;;;GAIG;AACH,MAAM,CAAC,MAAM,qBAAqB,GAAG,CAAC,oBAAoB,CAAC,CAAC;AAE5D,qEAAqE;AACrE,MAAM,CAAC,MAAM,oBAAoB,GAAG,CAAC,uBAAuB,CAAC,CAAC"}

package/dist/mcp-server/tools/shared/canvas-columns.d.ts

@@ -0,0 +1,32 @@
+/**
+ * @fileoverview Shared canvas column-name sanitizer. The two matrix-building
+ * tools (`brapi_build_phenotype_matrix`, `brapi_export_genotype_matrix`) pivot
+ * upstream IDs (`observationVariableDbId`, `variantDbId`) into dataframe column
+ * names. The framework's canvas registers tables through `assertValidIdentifier`,
+ * which rejects any column whose name fails `/^[A-Za-z_][A-Za-z0-9_]{0,62}$/` or
+ * matches a reserved SQL keyword. BrAPI DbIds are routinely numeric (Breedbase
+ * uses integers) or collide with reserved words, so column names must be
+ * sanitized to SQL-safe identifiers before registration — paired with a legend
+ * mapping the safe name back to the original ID so the correlation is never lost.
+ *
+ * @module mcp-server/tools/shared/canvas-columns
+ */
+/**
+ * Sanitize an arbitrary upstream ID into a valid DuckDB column identifier.
+ * Mirrors the framework's `CANVAS_IDENTIFIER_REGEX` (`/^[A-Za-z_][A-Za-z0-9_]{0,62}$/`):
+ * replace illegal characters with `_`, prefix `v_` when the result would start
+ * with a digit, truncate to 63 chars, and suffix `_` when the result collides
+ * with a reserved SQL keyword.
+ */
+export declare function sanitizeColumnName(raw: string): string;
+/**
+ * Sanitize a list of IDs into unique column names, preserving input order. When
+ * two IDs sanitize to the same name, later collisions get a numeric suffix
+ * (`_2`, `_3`, …). Returns the column names in order plus a legend mapping each
+ * safe column name back to its original ID.
+ */
+export declare function buildUniqueColumns(ids: readonly string[]): {
+    columns: string[];
+    toOriginal: Record<string, string>;
+};
+//# sourceMappingURL=canvas-columns.d.ts.map

package/dist/mcp-server/tools/shared/canvas-columns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-columns.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/shared/canvas-columns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AA+CH;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAStD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,SAAS,MAAM,EAAE,GAAG;IAC1D,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACpC,CAaA"}

package/dist/mcp-server/tools/shared/canvas-columns.js

@@ -0,0 +1,98 @@
+/**
+ * @fileoverview Shared canvas column-name sanitizer. The two matrix-building
+ * tools (`brapi_build_phenotype_matrix`, `brapi_export_genotype_matrix`) pivot
+ * upstream IDs (`observationVariableDbId`, `variantDbId`) into dataframe column
+ * names. The framework's canvas registers tables through `assertValidIdentifier`,
+ * which rejects any column whose name fails `/^[A-Za-z_][A-Za-z0-9_]{0,62}$/` or
+ * matches a reserved SQL keyword. BrAPI DbIds are routinely numeric (Breedbase
+ * uses integers) or collide with reserved words, so column names must be
+ * sanitized to SQL-safe identifiers before registration — paired with a legend
+ * mapping the safe name back to the original ID so the correlation is never lost.
+ *
+ * @module mcp-server/tools/shared/canvas-columns
+ */
+/**
+ * Reserved SQL keywords rejected by the framework canvas gate
+ * (`assertValidIdentifier`, reason `identifierReserved`). Kept in sync with the
+ * framework's `RESERVED_IDENTIFIERS` set — a sanitized name matching one of
+ * these (case-insensitive) is suffixed with `_` to clear the gate.
+ */
+const RESERVED_IDENTIFIERS = new Set([
+    'select',
+    'from',
+    'where',
+    'order',
+    'group',
+    'having',
+    'limit',
+    'offset',
+    'union',
+    'intersect',
+    'except',
+    'all',
+    'distinct',
+    'as',
+    'and',
+    'or',
+    'not',
+    'null',
+    'true',
+    'false',
+    'case',
+    'when',
+    'then',
+    'else',
+    'end',
+    'join',
+    'inner',
+    'outer',
+    'left',
+    'right',
+    'full',
+    'cross',
+    'on',
+    'using',
+    'with',
+    'recursive',
+]);
+/**
+ * Sanitize an arbitrary upstream ID into a valid DuckDB column identifier.
+ * Mirrors the framework's `CANVAS_IDENTIFIER_REGEX` (`/^[A-Za-z_][A-Za-z0-9_]{0,62}$/`):
+ * replace illegal characters with `_`, prefix `v_` when the result would start
+ * with a digit, truncate to 63 chars, and suffix `_` when the result collides
+ * with a reserved SQL keyword.
+ */
+export function sanitizeColumnName(raw) {
+    let name = raw.replace(/[^A-Za-z0-9_]/g, '_');
+    if (/^[0-9]/.test(name))
+        name = `v_${name}`;
+    if (name.length > 63)
+        name = name.slice(0, 63);
+    if (name.length === 0)
+        name = 'v_unknown';
+    if (RESERVED_IDENTIFIERS.has(name.toLowerCase())) {
+        name = name.length >= 63 ? `${name.slice(0, 62)}_` : `${name}_`;
+    }
+    return name;
+}
+/**
+ * Sanitize a list of IDs into unique column names, preserving input order. When
+ * two IDs sanitize to the same name, later collisions get a numeric suffix
+ * (`_2`, `_3`, …). Returns the column names in order plus a legend mapping each
+ * safe column name back to its original ID.
+ */
+export function buildUniqueColumns(ids) {
+    const used = new Map();
+    const columns = [];
+    const toOriginal = {};
+    for (const id of ids) {
+        const base = sanitizeColumnName(id);
+        const count = (used.get(base) ?? 0) + 1;
+        used.set(base, count);
+        const colName = count === 1 ? base : `${base}_${count}`;
+        columns.push(colName);
+        toOriginal[colName] = id;
+    }
+    return { columns, toOriginal };
+}
+//# sourceMappingURL=canvas-columns.js.map

package/dist/mcp-server/tools/shared/canvas-columns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"canvas-columns.js","sourceRoot":"","sources":["../../../../src/mcp-server/tools/shared/canvas-columns.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAEH;;;;;GAKG;AACH,MAAM,oBAAoB,GAAG,IAAI,GAAG,CAAC;IACnC,QAAQ;IACR,MAAM;IACN,OAAO;IACP,OAAO;IACP,OAAO;IACP,QAAQ;IACR,OAAO;IACP,QAAQ;IACR,OAAO;IACP,WAAW;IACX,QAAQ;IACR,KAAK;IACL,UAAU;IACV,IAAI;IACJ,KAAK;IACL,IAAI;IACJ,KAAK;IACL,MAAM;IACN,MAAM;IACN,OAAO;IACP,MAAM;IACN,MAAM;IACN,MAAM;IACN,MAAM;IACN,KAAK;IACL,MAAM;IACN,OAAO;IACP,OAAO;IACP,MAAM;IACN,OAAO;IACP,MAAM;IACN,OAAO;IACP,IAAI;IACJ,OAAO;IACP,MAAM;IACN,WAAW;CACZ,CAAC,CAAC;AAEH;;;;;;GAMG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAW;IAC5C,IAAI,IAAI,GAAG,GAAG,CAAC,OAAO,CAAC,gBAAgB,EAAE,GAAG,CAAC,CAAC;IAC9C,IAAI,QAAQ,CAAC,IAAI,CAAC,IAAI,CAAC;QAAE,IAAI,GAAG,KAAK,IAAI,EAAE,CAAC;IAC5C,IAAI,IAAI,CAAC,MAAM,GAAG,EAAE;QAAE,IAAI,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;IAC/C,IAAI,IAAI,CAAC,MAAM,KAAK,CAAC;QAAE,IAAI,GAAG,WAAW,CAAC;IAC1C,IAAI,oBAAoB,CAAC,GAAG,CAAC,IAAI,CAAC,WAAW,EAAE,CAAC,EAAE,CAAC;QACjD,IAAI,GAAG,IAAI,CAAC,MAAM,IAAI,EAAE,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,EAAE,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,CAAC;IAClE,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,kBAAkB,CAAC,GAAsB;IAIvD,MAAM,IAAI,GAAG,IAAI,GAAG,EAAkB,CAAC;IACvC,MAAM,OAAO,GAAa,EAAE,CAAC;IAC7B,MAAM,UAAU,GAA2B,EAAE,CAAC;IAC9C,KAAK,MAAM,EAAE,IAAI,GAAG,EAAE,CAAC;QACrB,MAAM,IAAI,GAAG,kBAAkB,CAAC,EAAE,CAAC,CAAC;QACpC,MAAM,KAAK,GAAG,CAAC,IAAI,CAAC,GAAG,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,GAAG,CAAC,CAAC;QACxC,IAAI,CAAC,GAAG,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC;QACtB,MAAM,OAAO,GAAG,KAAK,KAAK,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,GAAG,IAAI,IAAI,KAAK,EAAE,CAAC;QACxD,OAAO,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACtB,UAAU,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC;IAC3B,CAAC;IACD,OAAO,EAAE,OAAO,EAAE,UAAU,EAAE,CAAC;AACjC,CAAC"}

package/dist/mcp-server/tools/shared/genotype-calls.d.ts

@@ -0,0 +1,81 @@
+/**
+ * @fileoverview Shared genotype-call pull logic — the async-search machinery
+ * (`POST /search/calls` → poll → page-walk) and the `CallRow` schema extracted
+ * from `brapi-find-genotype-calls.tool.ts` so that `brapi_export_genotype_matrix`
+ * can reuse the same pull infrastructure without duplicating it.
+ *
+ * This module owns: the `CallRowSchema`, `CallFormatting` type, and the
+ * `collectCalls` / `consumePage` helpers. It does NOT contain `spillCalls` or
+ * any tool-level concerns — those stay in the consuming tool files.
+ *
+ * @module mcp-server/tools/shared/genotype-calls
+ */
+import { type Context, z } from '@cyanheads/mcp-ts-core';
+import type { BrapiClient } from '../../../services/brapi-client/index.js';
+import type { RegisteredServer } from '../../../services/server-registry/types.js';
+export declare const CallRowSchema: z.ZodObject<{
+    callSetDbId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    callSetName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    variantDbId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    variantName: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    variantSetDbId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    genotype: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        values: z.ZodOptional<z.ZodNullable<z.ZodArray<z.ZodString>>>;
+    }, z.core.$loose>>>;
+    genotypeValue: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    phaseSet: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$loose>;
+export type CallRow = z.infer<typeof CallRowSchema>;
+export interface CallFormatting {
+    expandHomozygotes?: boolean | null;
+    sepPhased?: string | null;
+    sepUnphased?: string | null;
+    unknownString?: string | null;
+}
+export interface CollectCallsInput {
+    body: Record<string, unknown>;
+    client: BrapiClient;
+    connection: RegisteredServer;
+    ctx: Context;
+    maxCalls: number;
+    warnings: string[];
+}
+export interface CollectCallsResult {
+    callFormatting: CallFormatting;
+    rows: CallRow[];
+    truncated: boolean;
+}
+/**
+ * Build the POST /search/calls body from named filter params. Handles both the
+ * singular `variantSetDbId` convenience and the plural `variantSetDbIds` array,
+ * merging and deduplicating them.
+ */
+export declare function buildCallsSearchBody(input: {
+    variantSetDbId?: string | undefined;
+    variantSetDbIds?: string[] | undefined;
+    germplasmDbIds?: string[] | undefined;
+    callSetDbIds?: string[] | undefined;
+    variantDbIds?: string[] | undefined;
+    callFormat?: string | undefined;
+}): Record<string, unknown>;
+/**
+ * Pull all genotype call pages for a given search body, capping at `maxCalls`.
+ * Uses BrAPI's async-search pattern: `POST /search/calls` → `GET /search/calls/{id}`
+ * with 202-retry. Pages are collected until all results are fetched or `maxCalls`
+ * is reached.
+ */
+export declare function collectCalls(input: CollectCallsInput): Promise<CollectCallsResult>;
+/**
+ * Extract call rows and `callFormatting` hints from one BrAPI envelope page.
+ * Mutates `rows` in-place; invokes `setCallFormatting` when formatting hints
+ * are present so the caller can merge across pages.
+ */
+export declare function consumePage(envelope: Awaited<ReturnType<BrapiClient['get']>>, rows: CallRow[], setCallFormatting: (f: CallFormatting) => void): void;
+/**
+ * Render the genotype string for one call row given the server's callFormatting
+ * hints. Prefers `genotype.values` joined with the appropriate separator;
+ * falls back to `genotypeValue`; returns the `unknownString` (or ".") when
+ * no data is available.
+ */
+export declare function renderGenotypeString(row: CallRow, callFormatting: CallFormatting, phased?: boolean): string;
+//# sourceMappingURL=genotype-calls.d.ts.map

package/dist/mcp-server/tools/shared/genotype-calls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"genotype-calls.d.ts","sourceRoot":"","sources":["../../../../src/mcp-server/tools/shared/genotype-calls.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,KAAK,OAAO,EAAE,CAAC,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,kCAAkC,CAAC;AACpE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qCAAqC,CAAC;AAK5E,eAAO,MAAM,aAAa;;;;;;;;;;;iBAkCW,CAAC;AAEtC,MAAM,MAAM,OAAO,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,aAAa,CAAC,CAAC;AAEpD,MAAM,WAAW,cAAc;IAC7B,iBAAiB,CAAC,EAAE,OAAO,GAAG,IAAI,CAAC;IACnC,SAAS,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC1B,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IAC5B,aAAa,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;CAC/B;AAED,MAAM,WAAW,iBAAiB;IAChC,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC9B,MAAM,EAAE,WAAW,CAAC;IACpB,UAAU,EAAE,gBAAgB,CAAC;IAC7B,GAAG,EAAE,OAAO,CAAC;IACb,QAAQ,EAAE,MAAM,CAAC;IACjB,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED,MAAM,WAAW,kBAAkB;IACjC,cAAc,EAAE,cAAc,CAAC;IAC/B,IAAI,EAAE,OAAO,EAAE,CAAC;IAChB,SAAS,EAAE,OAAO,CAAC;CACpB;AAED;;;;GAIG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE;IAC1C,cAAc,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;IACpC,eAAe,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACvC,cAAc,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACtC,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACpC,YAAY,CAAC,EAAE,MAAM,EAAE,GAAG,SAAS,CAAC;IACpC,UAAU,CAAC,EAAE,MAAM,GAAG,SAAS,CAAC;CACjC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAc1B;AAED;;;;;GAKG;AACH,wBAAsB,YAAY,CAAC,KAAK,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,CAAC,CAmFxF;AAED;;;;GAIG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC,EACjD,IAAI,EAAE,OAAO,EAAE,EACf,iBAAiB,EAAE,CAAC,CAAC,EAAE,cAAc,KAAK,IAAI,GAC7C,IAAI,CAmBN;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAClC,GAAG,EAAE,OAAO,EACZ,cAAc,EAAE,cAAc,EAC9B,MAAM,CAAC,EAAE,OAAO,GACf,MAAM,CASR"}

package/dist/mcp-server/tools/shared/genotype-calls.js

@@ -0,0 +1,172 @@
+/**
+ * @fileoverview Shared genotype-call pull logic — the async-search machinery
+ * (`POST /search/calls` → poll → page-walk) and the `CallRow` schema extracted
+ * from `brapi-find-genotype-calls.tool.ts` so that `brapi_export_genotype_matrix`
+ * can reuse the same pull infrastructure without duplicating it.
+ *
+ * This module owns: the `CallRowSchema`, `CallFormatting` type, and the
+ * `collectCalls` / `consumePage` helpers. It does NOT contain `spillCalls` or
+ * any tool-level concerns — those stay in the consuming tool files.
+ *
+ * @module mcp-server/tools/shared/genotype-calls
+ */
+import { z } from '@cyanheads/mcp-ts-core';
+import { buildRequestOptions } from './find-helpers.js';
+const PAGE_SIZE = 10_000;
+export const CallRowSchema = z
+    .object({
+    callSetDbId: z
+        .string()
+        .nullish()
+        .describe('FK to the call set (one germplasm × one variant set = one call set).'),
+    callSetName: z.string().nullish().describe('Display name of the call set.'),
+    variantDbId: z.string().nullish().describe('FK to the variant being called.'),
+    variantName: z.string().nullish().describe('Display name / alias of the variant.'),
+    variantSetDbId: z.string().nullish().describe('FK to the variant set the call belongs to.'),
+    genotype: z
+        .object({
+        values: z
+            .array(z.string().describe('Per-allele value string.'))
+            .nullish()
+            .describe('Encoded allele values — interpret using top-level `callFormatting`.'),
+    })
+        .passthrough()
+        .nullish()
+        .describe('Structured genotype payload (array of allele values plus server-specific fields).'),
+    genotypeValue: z
+        .string()
+        .nullish()
+        .describe('Legacy flat string form of the call (provided by some servers instead of `genotype`).'),
+    phaseSet: z
+        .string()
+        .nullish()
+        .describe('Phase-set identifier linking calls that share a haplotype phase.'),
+})
+    .passthrough()
+    .describe('One genotype call row.');
+/**
+ * Build the POST /search/calls body from named filter params. Handles both the
+ * singular `variantSetDbId` convenience and the plural `variantSetDbIds` array,
+ * merging and deduplicating them.
+ */
+export function buildCallsSearchBody(input) {
+    const body = {};
+    if (input.variantSetDbId)
+        body.variantSetDbIds = [input.variantSetDbId];
+    if (input.variantSetDbIds?.length) {
+        body.variantSetDbIds = Array.from(new Set([...(body.variantSetDbIds ?? []), ...input.variantSetDbIds]));
+    }
+    if (input.germplasmDbIds?.length)
+        body.germplasmDbIds = input.germplasmDbIds;
+    if (input.callSetDbIds?.length)
+        body.callSetDbIds = input.callSetDbIds;
+    if (input.variantDbIds?.length)
+        body.variantDbIds = input.variantDbIds;
+    if (input.callFormat)
+        body.callFormat = input.callFormat;
+    body.pageSize = PAGE_SIZE;
+    return body;
+}
+/**
+ * Pull all genotype call pages for a given search body, capping at `maxCalls`.
+ * Uses BrAPI's async-search pattern: `POST /search/calls` → `GET /search/calls/{id}`
+ * with 202-retry. Pages are collected until all results are fetched or `maxCalls`
+ * is reached.
+ */
+export async function collectCalls(input) {
+    const rows = [];
+    let callFormatting = {};
+    let truncated = false;
+    const firstBody = { ...input.body, page: 0 };
+    const first = await input.client.postSearch(input.connection.baseUrl, 'calls', firstBody, input.ctx, buildRequestOptions(input.connection));
+    let envelope;
+    let searchResultsDbId;
+    if (first.kind === 'sync') {
+        envelope = first.envelope;
+    }
+    else {
+        searchResultsDbId = first.searchResultsDbId;
+        envelope = await input.client.getSearchResults(input.connection.baseUrl, 'calls', first.searchResultsDbId, input.ctx, buildRequestOptions(input.connection));
+    }
+    consumePage(envelope, rows, (cf) => {
+        callFormatting = cf;
+    });
+    const totalPages = envelope.metadata?.pagination?.totalPages;
+    for (let page = 1; page < (totalPages ?? 1); page++) {
+        if (rows.length >= input.maxCalls) {
+            truncated = true;
+            break;
+        }
+        if (input.ctx.signal.aborted)
+            break;
+        let pageEnvelope;
+        if (searchResultsDbId) {
+            pageEnvelope = await input.client.getSearchResults(input.connection.baseUrl, 'calls', searchResultsDbId, input.ctx, buildRequestOptions(input.connection, { page, pageSize: PAGE_SIZE }));
+        }
+        else {
+            const nextSearch = await input.client.postSearch(input.connection.baseUrl, 'calls', { ...input.body, page }, input.ctx, buildRequestOptions(input.connection));
+            if (nextSearch.kind === 'sync') {
+                pageEnvelope = nextSearch.envelope;
+            }
+            else {
+                pageEnvelope = await input.client.getSearchResults(input.connection.baseUrl, 'calls', nextSearch.searchResultsDbId, input.ctx, buildRequestOptions(input.connection));
+            }
+        }
+        consumePage(pageEnvelope, rows, (cf) => {
+            callFormatting = cf;
+        });
+    }
+    if (rows.length > input.maxCalls) {
+        rows.length = input.maxCalls;
+        truncated = true;
+        input.warnings.push(`Truncated at the deployment pull limit (${input.maxCalls} rows). Narrow the filters and re-pull; the captured slice is preserved in the spilled dataframe.`);
+    }
+    return { rows, callFormatting, truncated };
+}
+/**
+ * Extract call rows and `callFormatting` hints from one BrAPI envelope page.
+ * Mutates `rows` in-place; invokes `setCallFormatting` when formatting hints
+ * are present so the caller can merge across pages.
+ */
+export function consumePage(envelope, rows, setCallFormatting) {
+    const result = envelope.result;
+    if (!result || typeof result !== 'object')
+        return;
+    const record = result;
+    const cf = {};
+    if (typeof record.expandHomozygotes === 'boolean')
+        cf.expandHomozygotes = record.expandHomozygotes;
+    if (typeof record.unknownString === 'string')
+        cf.unknownString = record.unknownString;
+    if (typeof record.sepPhased === 'string')
+        cf.sepPhased = record.sepPhased;
+    if (typeof record.sepUnphased === 'string')
+        cf.sepUnphased = record.sepUnphased;
+    setCallFormatting(cf);
+    const data = record.data;
+    if (!Array.isArray(data))
+        return;
+    for (const entry of data) {
+        if (typeof entry === 'object' && entry !== null) {
+            rows.push(entry);
+        }
+    }
+}
+/**
+ * Render the genotype string for one call row given the server's callFormatting
+ * hints. Prefers `genotype.values` joined with the appropriate separator;
+ * falls back to `genotypeValue`; returns the `unknownString` (or ".") when
+ * no data is available.
+ */
+export function renderGenotypeString(row, callFormatting, phased) {
+    const unknown = callFormatting.unknownString ?? '.';
+    const values = row.genotype?.values;
+    if (values && values.length > 0) {
+        const sep = phased ? (callFormatting.sepPhased ?? '|') : (callFormatting.sepUnphased ?? '/');
+        return values.join(sep);
+    }
+    if (row.genotypeValue)
+        return row.genotypeValue;
+    return unknown;
+}
+//# sourceMappingURL=genotype-calls.js.map