@malloy-publisher/server 0.0.181 → 0.0.182

package/dist/server.js

@@ -222749,7 +222749,7 @@ class ModelController {
     }
     return model.getNotebook();
   }
-  async executeNotebookCell(projectName, packageName, notebookPath, cellIndex) {
+  async executeNotebookCell(projectName, packageName, notebookPath, cellIndex, filterParams, bypassFilters) {
     const project = await this.projectStore.getProject(projectName, false);
     const p = await project.getPackage(packageName, false);
     const model = p.getModel(notebookPath);
@@ -222759,7 +222759,7 @@ class ModelController {
     if (model.getType() === "model") {
       throw new ModelNotFoundError(`${notebookPath} is a model`);
     }
-    return model.executeNotebookCell(cellIndex);
+    return model.executeNotebookCell(cellIndex, filterParams, bypassFilters);
   }
 }
 
@@ -222849,14 +222849,14 @@ class QueryController {
   constructor(projectStore) {
     this.projectStore = projectStore;
   }
-  async getQuery(projectName, packageName, modelPath, sourceName, queryName, query, compactJson = false) {
+  async getQuery(projectName, packageName, modelPath, sourceName, queryName, query, compactJson = false, filterParams, bypassFilters) {
     const project = await this.projectStore.getProject(projectName, false);
     const p = await project.getPackage(packageName, false);
     const model = p.getModel(modelPath);
     if (!model) {
       throw new ModelNotFoundError(`${modelPath} does not exist`);
     } else {
-      const { result, compactResult } = await model.getQueryResults(sourceName, queryName, query);
+      const { result, compactResult } = await model.getQueryResults(sourceName, queryName, query, filterParams, bypassFilters);
       const renderLogs = import_render_validator.validateRenderTags(result);
       return {
         result: compactJson ? JSON.stringify(compactResult, bigIntReplacer) : JSON.stringify(result),
@@ -229601,6 +229601,196 @@ class HackyDataStylesAccumulator {
   }
 }
 
+// src/service/filter.ts
+var VALID_FILTER_TYPES = new Set([
+  "equal",
+  "in",
+  "like",
+  "greater_than",
+  "less_than"
+]);
+var ANNOTATION_PREFIX = "#(filter)";
+function parseFilterAnnotation(annotation) {
+  const trimmed2 = annotation.trim();
+  if (!trimmed2.startsWith(ANNOTATION_PREFIX)) {
+    return null;
+  }
+  const body = trimmed2.slice(ANNOTATION_PREFIX.length).trim();
+  const tokens = tokenize(body);
+  let name;
+  let dimension;
+  let type;
+  let implicit = false;
+  let required = false;
+  for (const token of tokens) {
+    if (token.includes("=")) {
+      const eqIndex = token.indexOf("=");
+      const key = token.slice(0, eqIndex).toLowerCase();
+      const value = token.slice(eqIndex + 1);
+      switch (key) {
+        case "name":
+          name = value;
+          break;
+        case "dimension":
+          dimension = value;
+          break;
+        case "type":
+          if (!VALID_FILTER_TYPES.has(value)) {
+            throw new Error(`Invalid filter type "${value}". Must be one of: ${[...VALID_FILTER_TYPES].join(", ")}`);
+          }
+          type = value;
+          break;
+        default:
+          throw new Error(`Unknown filter parameter "${key}"`);
+      }
+    } else {
+      const flag = token.toLowerCase();
+      if (flag === "implicit") {
+        implicit = true;
+      } else if (flag === "required") {
+        required = true;
+      } else {
+        throw new Error(`Unknown filter flag "${token}"`);
+      }
+    }
+  }
+  if (!dimension) {
+    throw new Error("filter annotation missing required 'dimension' parameter");
+  }
+  if (!type) {
+    throw new Error("filter annotation missing required 'type' parameter");
+  }
+  return {
+    name: name ?? dimension,
+    dimension,
+    type,
+    implicit,
+    required
+  };
+}
+function parseFilters(annotations) {
+  const filters = [];
+  for (const annotation of annotations) {
+    const parsed = parseFilterAnnotation(annotation);
+    if (parsed) {
+      filters.push(parsed);
+    }
+  }
+  return filters;
+}
+function escapeMalloyString(value) {
+  return value.replace(/\\/g, "\\\\").replace(/'/g, "\\'");
+}
+function isBooleanLiteral(v) {
+  const lower = v.toLowerCase();
+  return lower === "true" || lower === "false";
+}
+var ISO_DATE_RE = /^\d{4}-\d{2}-\d{2}$/;
+var ISO_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}[T ]\d{2}:\d{2}/;
+function isDateLiteral(v) {
+  return ISO_DATE_RE.test(v) || ISO_TIMESTAMP_RE.test(v);
+}
+function malloyLiteral(v) {
+  if (isBooleanLiteral(v)) {
+    return v.toLowerCase();
+  }
+  if (isDateLiteral(v)) {
+    return `@${v.slice(0, 10)}`;
+  }
+  return `'${escapeMalloyString(v)}'`;
+}
+function buildPredicate(filter2, value) {
+  const dim = `\`${filter2.dimension}\``;
+  switch (filter2.type) {
+    case "equal": {
+      const v = Array.isArray(value) ? value[0] : value;
+      return `${dim} = ${malloyLiteral(v)}`;
+    }
+    case "in": {
+      const values = Array.isArray(value) ? value : [value];
+      if (values.length === 1) {
+        return `${dim} = ${malloyLiteral(values[0])}`;
+      }
+      const conditions = values.map((v) => `${dim} = ${malloyLiteral(v)}`);
+      return `(${conditions.join(" or ")})`;
+    }
+    case "like": {
+      const v = Array.isArray(value) ? value[0] : value;
+      const escaped = escapeMalloyString(v.toLowerCase());
+      const pattern = escaped.startsWith("%") || escaped.endsWith("%") ? escaped : `%${escaped}%`;
+      return `lower(${dim}) ~ '${pattern}'`;
+    }
+    case "greater_than": {
+      const v = Array.isArray(value) ? value[0] : value;
+      return `${dim} > ${malloyLiteral(v)}`;
+    }
+    case "less_than": {
+      const v = Array.isArray(value) ? value[0] : value;
+      return `${dim} < ${malloyLiteral(v)}`;
+    }
+  }
+}
+function buildFilterClause(filters, params) {
+  const predicates2 = [];
+  for (const filter2 of filters) {
+    const value = params[filter2.name];
+    const hasValue = value !== undefined && value !== null && (Array.isArray(value) ? value.length > 0 : value !== "");
+    if (!hasValue) {
+      if (filter2.required) {
+        throw new FilterValidationError(`Required filter "${filter2.name}" (dimension: ${filter2.dimension}) was not provided`);
+      }
+      continue;
+    }
+    predicates2.push(buildPredicate(filter2, value));
+  }
+  if (predicates2.length === 0) {
+    return "";
+  }
+  return predicates2.join(" and ");
+}
+function injectFilterRefinement(query, filterClause) {
+  if (!filterClause) {
+    return query;
+  }
+  return `${query.trimEnd()} + {where: ${filterClause}}`;
+}
+
+class FilterValidationError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "FilterValidationError";
+  }
+}
+function tokenize(input) {
+  const tokens = [];
+  let current = "";
+  let inQuote = false;
+  let quoteChar = "";
+  for (const ch of input) {
+    if (inQuote) {
+      if (ch === quoteChar) {
+        inQuote = false;
+      } else {
+        current += ch;
+      }
+    } else if (ch === '"' || ch === "'") {
+      inQuote = true;
+      quoteChar = ch;
+    } else if (ch === " " || ch === "\t") {
+      if (current) {
+        tokens.push(current);
+        current = "";
+      }
+    } else {
+      current += ch;
+    }
+  }
+  if (current) {
+    tokens.push(current);
+  }
+  return tokens;
+}
+
 // src/service/model.ts
 var MALLOY_VERSION = import__package.default.version;
 
@@ -229617,12 +229807,13 @@ class Model {
   sourceInfos;
   runnableNotebookCells;
   compilationError;
+  filterMap;
   meter = import_api2.metrics.getMeter("publisher");
   queryExecutionHistogram = this.meter.createHistogram("malloy_model_query_duration", {
     description: "How long it takes to execute a Malloy model query",
     unit: "ms"
   });
-  constructor(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, sourceInfos, runnableNotebookCells, compilationError) {
+  constructor(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, sourceInfos, runnableNotebookCells, compilationError, filterMap) {
     this.packageName = packageName;
     this.modelPath = modelPath;
     this.dataStyles = dataStyles;
@@ -229634,8 +229825,19 @@ class Model {
     this.sourceInfos = sourceInfos;
     this.runnableNotebookCells = runnableNotebookCells;
     this.compilationError = compilationError;
+    this.filterMap = filterMap ?? new Map;
     this.modelInfo = this.modelDef ? import_malloy2.modelDefToModelInfo(this.modelDef) : undefined;
   }
+  getFilters(sourceName) {
+    return this.filterMap.get(sourceName) ?? [];
+  }
+  extractSourceName(query) {
+    if (!query)
+      return;
+    const runMatch = query.match(/run\s*:\s*(\w+)\s*->/);
+    const arrowMatch = query.match(/^\s*(\w+)\s*->/m);
+    return runMatch?.[1] ?? arrowMatch?.[1];
+  }
   static async create(packageName, packagePath, modelPath, connections) {
     const { runtime, modelURL, importBaseURL, dataStyles, modelType } = await Model.getModelRuntime(packagePath, modelPath, connections);
     try {
@@ -229643,10 +229845,13 @@ class Model {
       let modelDef = undefined;
       let sources = undefined;
       let queries = undefined;
+      let filterMap;
       const sourceInfos = [];
       if (modelMaterializer) {
         modelDef = (await modelMaterializer.getModel())._modelDef;
-        sources = Model.getSources(modelPath, modelDef);
+        const sourceResult = Model.getSources(modelPath, modelDef);
+        sources = sourceResult.sources;
+        filterMap = sourceResult.filterMap;
         queries = Model.getQueries(modelPath, modelDef);
         const imports = modelDef.imports || [];
         const importedSourceNames = new Set;
@@ -229677,7 +229882,7 @@ class Model {
           }
         }
       }
-      return new Model(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, sourceInfos.length > 0 ? sourceInfos : undefined, runnableNotebookCells, undefined);
+      return new Model(packageName, modelPath, dataStyles, modelType, modelMaterializer, modelDef, sources, queries, sourceInfos.length > 0 ? sourceInfos : undefined, runnableNotebookCells, undefined, filterMap);
     } catch (error) {
       let computedError = error;
       if (error instanceof Error && error.stack) {
@@ -229731,7 +229936,7 @@ class Model {
       throw new ModelNotFoundError(`${this.modelPath} is not a valid notebook name.  Notebook files must end in .malloynb.`);
     }
   }
-  async getQueryResults(sourceName, queryName, query) {
+  async getQueryResults(sourceName, queryName, query, filterParams, bypassFilters) {
     const startTime = performance.now();
     if (this.compilationError) {
       if (this.compilationError instanceof import_malloy2.MalloyError || this.compilationError instanceof ModelCompilationError) {
@@ -229743,12 +229948,13 @@ class Model {
     if (!this.modelMaterializer || !this.modelDef || !this.modelInfo)
       throw new BadRequestError("Model has no queryable entities.");
     try {
+      let queryString;
       if (!sourceName && !queryName && query) {
-        runnable = this.modelMaterializer.loadQuery(`
-` + query);
+        queryString = `
+` + query;
       } else if (queryName && !query) {
-        runnable = this.modelMaterializer.loadQuery(`
-run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
+        queryString = `
+run: ${sourceName ? sourceName + "->" : ""}${queryName}`;
       } else {
         const endTime2 = performance.now();
         const executionTime2 = endTime2 - startTime;
@@ -229761,10 +229967,24 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
         });
         throw new BadRequestError("Invalid query request. (Query AND !sourceName) OR (queryName AND sourceName) must be defined.");
       }
+      if (!bypassFilters) {
+        const effectiveSource = sourceName ?? this.extractSourceName(query);
+        if (effectiveSource) {
+          const filters = this.getFilters(effectiveSource);
+          if (filters.length > 0) {
+            const filterClause = buildFilterClause(filters, filterParams ?? {});
+            queryString = injectFilterRefinement(queryString, filterClause);
+          }
+        }
+      }
+      runnable = this.modelMaterializer.loadQuery(queryString);
     } catch (error) {
       if (error instanceof BadRequestError) {
         throw error;
       }
+      if (error instanceof FilterValidationError) {
+        throw new BadRequestError(error.message);
+      }
       if (error instanceof import_malloy2.MalloyError) {
         throw error;
       }
@@ -229874,7 +230094,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
       notebookCells
     };
   }
-  async executeNotebookCell(cellIndex) {
+  async executeNotebookCell(cellIndex, filterParams, bypassFilters) {
     if (this.compilationError) {
       throw this.compilationError;
     }
@@ -229895,12 +230115,29 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
     let queryResult = undefined;
     if (cell.runnable) {
       try {
-        const rowLimit = (await cell.runnable.getPreparedResult()).resultExplore.limit || ROW_LIMIT;
-        const result = await cell.runnable.run({ rowLimit });
-        const query = (await cell.runnable.getPreparedQuery())._query;
+        let runnableToExecute = cell.runnable;
+        if (!bypassFilters && cell.modelMaterializer) {
+          const effectiveSource = this.extractSourceName(cell.text);
+          if (effectiveSource) {
+            const filters = this.getFilters(effectiveSource);
+            if (filters.length > 0) {
+              const filterClause = buildFilterClause(filters, filterParams ?? {});
+              if (filterClause) {
+                const refinedQuery = injectFilterRefinement(cell.text, filterClause);
+                runnableToExecute = cell.modelMaterializer.loadQuery(refinedQuery);
+              }
+            }
+          }
+        }
+        const rowLimit = (await runnableToExecute.getPreparedResult()).resultExplore.limit || ROW_LIMIT;
+        const result = await runnableToExecute.run({ rowLimit });
+        const query = (await runnableToExecute.getPreparedQuery())._query;
         queryName = query.as || query.name;
         queryResult = result?._queryResult && this.modelInfo && JSON.stringify(import_malloy2.API.util.wrapResult(result));
       } catch (error) {
+        if (error instanceof FilterValidationError) {
+          throw new BadRequestError(error.message);
+        }
         if (error instanceof import_malloy2.MalloyError) {
           throw error;
         }
@@ -229966,14 +230203,46 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
     }));
   }
   static getSources(modelPath, modelDef) {
-    return Object.values(modelDef.contents).filter((obj) => import_malloy2.isSourceDef(obj)).map((sourceObj) => ({
-      name: sourceObj.as || sourceObj.name,
-      annotations: sourceObj.annotation?.blockNotes?.filter((note) => note.at.url.includes(modelPath)).map((note) => note.text),
-      views: sourceObj.fields.filter((turtleObj) => turtleObj.type === "turtle").filter((turtleObj) => turtleObj.pipeline.map((stage) => stage.type).every((type) => type == "reduce")).map((turtleObj) => ({
+    const filterMap = new Map;
+    const sources = Object.values(modelDef.contents).filter((obj) => import_malloy2.isSourceDef(obj)).map((sourceObj) => {
+      const sourceName = sourceObj.as || sourceObj.name;
+      const annotations = sourceObj.annotation?.blockNotes?.filter((note) => note.at.url.includes(modelPath)).map((note) => note.text);
+      const allAnnotations = sourceObj.annotation?.blockNotes?.map((note) => note.text);
+      let filters;
+      if (allAnnotations && allAnnotations.length > 0) {
+        try {
+          const parsed = parseFilters(allAnnotations);
+          if (parsed.length > 0) {
+            filterMap.set(sourceName, parsed);
+            const structFields = sourceObj.fields;
+            filters = parsed.map((f) => {
+              const field = structFields.find((fd) => (fd.as || fd.name) === f.dimension);
+              return {
+                name: f.name,
+                dimension: f.dimension,
+                type: f.type,
+                implicit: f.implicit,
+                required: f.required,
+                dimensionType: field?.type
+              };
+            });
+          }
+        } catch (err) {
+          logger.warn(`Failed to parse filter annotations on source "${sourceName}"`, { error: err });
+        }
+      }
+      const views = sourceObj.fields.filter((turtleObj) => turtleObj.type === "turtle").filter((turtleObj) => turtleObj.pipeline.map((stage) => stage.type).every((type) => type == "reduce")).map((turtleObj) => ({
         name: turtleObj.as || turtleObj.name,
         annotations: turtleObj?.annotation?.blockNotes?.filter((note) => note.at.url.includes(modelPath)).map((note) => note.text)
-      }))
-    }));
+      }));
+      return {
+        name: sourceName,
+        annotations,
+        views,
+        filters
+      };
+    });
+    return { sources, filterMap };
   }
   static async getModelMaterializer(runtime, importBaseURL, modelURL, modelPath) {
     if (modelPath.endsWith(MODEL_FILE_SUFFIX)) {
@@ -230072,6 +230341,7 @@ run: ${sourceName ? sourceName + "->" : ""}${queryName}`);
           type: "code",
           text: stmt.text,
           runnable,
+          modelMaterializer: localMM,
           newSources,
           queryInfo
         };
@@ -234789,9 +235059,14 @@ function registerModelResource(mcpServer, projectStore) {
         throw new ModelNotFoundError(modelPath);
       }
       const compiledModelDefinition = await modelInstance.getModel();
-      return {
-        ...compiledModelDefinition
-      };
+      if (compiledModelDefinition.sources) {
+        for (const source of compiledModelDefinition.sources) {
+          if (source.filters) {
+            source.filters = source.filters.filter((f) => !f.implicit);
+          }
+        }
+      }
+      return compiledModelDefinition;
     } catch (error) {
       let errorDetails;
       const safeProjectName = typeof projectName === "string" ? projectName : "unknown";
@@ -235190,6 +235465,9 @@ function registerSourceResource(mcpServer, projectStore) {
         const errorDetails = getNotFoundError(`Source '${sourceName}' in model '${modelPath}' package '${packageName}' project '${projectName}'`);
         throw new McpGetResourceError(errorDetails);
       }
+      if (source.filters) {
+        source.filters = source.filters.filter((f) => !f.implicit);
+      }
       return source;
     } catch (error) {
       if (error instanceof McpGetResourceError) {
@@ -235422,7 +235700,8 @@ var executeQueryShape = {
   modelPath: exports_external.string().describe("Path to the .malloy model file"),
   query: exports_external.string().optional().describe("Ad-hoc Malloy query code"),
   sourceName: exports_external.string().optional().describe("Source name for a view"),
-  queryName: exports_external.string().optional().describe("Named query or view")
+  queryName: exports_external.string().optional().describe("Named query or view"),
+  filterParams: exports_external.record(exports_external.union([exports_external.string(), exports_external.array(exports_external.string())])).optional().describe("Filter parameter values keyed by filter name. Used with sources that declare #(filter) annotations.")
 };
 function registerExecuteQueryTool(mcpServer, projectStore) {
   mcpServer.tool("malloy_executeQuery", "Executes a Malloy query (either ad-hoc or a named query/view defined in a model) against the specified model and returns the results as JSON.", executeQueryShape, async (params) => {
@@ -235432,7 +235711,8 @@ function registerExecuteQueryTool(mcpServer, projectStore) {
       modelPath,
       query,
       sourceName,
-      queryName
+      queryName,
+      filterParams
     } = params;
     logger.info("[MCP Tool executeQuery] Received params:", { params });
     const hasAdhocQuery = !!query;
@@ -235468,7 +235748,7 @@ function registerExecuteQueryTool(mcpServer, projectStore) {
     logger.info(`[MCP Tool executeQuery] Model found. Proceeding to execute query.`);
     try {
       if (query) {
-        const { result } = await model.getQueryResults(undefined, undefined, query);
+        const { result } = await model.getQueryResults(undefined, undefined, query, filterParams);
         const { validateRenderTags: validateRenderTags2 } = await Promise.resolve().then(() => __toESM(require_dist10()));
         const renderLogs = validateRenderTags2(result);
         const baseUriComponents = {
@@ -235504,7 +235784,7 @@ ${JSON.stringify(renderLogs, null, 2)}`
         }
         return { isError: false, content };
       } else if (queryName) {
-        const { result } = await model.getQueryResults(sourceName, queryName, undefined);
+        const { result } = await model.getQueryResults(sourceName, queryName, undefined, filterParams);
         const { validateRenderTags: validateRenderTags2 } = await Promise.resolve().then(() => __toESM(require_dist10()));
         const renderLogs = validateRenderTags2(result);
         const baseUriComponents = {
@@ -236085,7 +236365,19 @@ app.get(`${API_PREFIX2}/projects/:projectName/packages/:packageName/notebooks/*/
       return;
     }
     const notebookPath = req.params["0"];
-    res.status(200).json(await modelController.executeNotebookCell(req.params.projectName, req.params.packageName, notebookPath, cellIndex));
+    let filterParams;
+    if (typeof req.query.filter_params === "string") {
+      try {
+        filterParams = JSON.parse(req.query.filter_params);
+      } catch {
+        res.status(400).json({
+          error: "Invalid filter_params: must be valid JSON"
+        });
+        return;
+      }
+    }
+    const bypassFilters = req.query.bypass_filters === "true" ? true : undefined;
+    res.status(200).json(await modelController.executeNotebookCell(req.params.projectName, req.params.packageName, notebookPath, cellIndex, filterParams, bypassFilters));
   } catch (error) {
     logger.error(error);
     const { json: json2, status } = internalErrorToHttpError(error);
@@ -236113,7 +236405,7 @@ app.post(`${API_PREFIX2}/projects/:projectName/packages/:packageName/models/*?/q
   }
   try {
     const modelPath = req.params["0"];
-    res.status(200).json(await queryController.getQuery(req.params.projectName, req.params.packageName, modelPath, req.body.sourceName, req.body.queryName, req.body.query, req.body.compactJson === true));
+    res.status(200).json(await queryController.getQuery(req.params.projectName, req.params.packageName, modelPath, req.body.sourceName, req.body.queryName, req.body.query, req.body.compactJson === true, req.body.filterParams ?? req.body.sourceFilters, req.body.bypassFilters === true ? true : undefined));
   } catch (error) {
     logger.error(error);
     const { json: json2, status } = internalErrorToHttpError(error);

package/package.json

@@ -1,7 +1,7 @@
 {
    "name": "@malloy-publisher/server",
    "description": "Malloy Publisher Server",
-   "version": "0.0.181",
+   "version": "0.0.182",
    "main": "dist/server.js",
    "bin": {
       "malloy-publisher": "dist/server.js"

package/src/controller/model.controller.ts

@@ -1,6 +1,7 @@
 import { components } from "../api";
 import { ModelNotFoundError } from "../errors";
 import { ProjectStore } from "../service/project_store";
+import type { FilterParams } from "../service/filter";
 
 type ApiNotebook = components["schemas"]["Notebook"];
 type ApiModel = components["schemas"]["Model"];
@@ -84,6 +85,8 @@ export class ModelController {
       packageName: string,
       notebookPath: string,
       cellIndex: number,
+      filterParams?: FilterParams,
+      bypassFilters?: boolean,
    ): Promise<{
       type: "code" | "markdown";
       text: string;
@@ -101,6 +104,6 @@ export class ModelController {
          throw new ModelNotFoundError(`${notebookPath} is a model`);
       }
 
-      return model.executeNotebookCell(cellIndex);
+      return model.executeNotebookCell(cellIndex, filterParams, bypassFilters);
    }
 }

package/src/controller/query.controller.ts

@@ -3,6 +3,7 @@ import { components } from "../api";
 import { API_PREFIX } from "../constants";
 import { ModelNotFoundError } from "../errors";
 import { ProjectStore } from "../service/project_store";
+import type { FilterParams } from "../service/filter";
 
 type ApiQuery = components["schemas"]["QueryResult"];
 
@@ -29,6 +30,8 @@ export class QueryController {
       queryName: string,
       query: string,
       compactJson: boolean = false,
+      filterParams?: FilterParams,
+      bypassFilters?: boolean,
    ): Promise<ApiQuery> {
       const project = await this.projectStore.getProject(projectName, false);
       const p = await project.getPackage(packageName, false);
@@ -41,6 +44,8 @@ export class QueryController {
             sourceName,
             queryName,
             query,
+            filterParams,
+            bypassFilters,
          );
          const renderLogs = validateRenderTags(result);
          return {

package/src/mcp/resources/model_resource.ts

@@ -82,15 +82,18 @@ export function registerModelResource(
                   const compiledModelDefinition: components["schemas"]["CompiledModel"] =
                      await modelInstance.getModel();
 
-                  // Return the definition, potentially adding identifiers back if needed
-                  // (Check if compiledModelDefinition already includes them)
-                  return {
-                     ...compiledModelDefinition,
-                     // Ensure these are present if not already in compiledModelDefinition
-                     // path: modelPath,
-                     // packageName: packageName,
-                     // projectName: projectName
-                  };
+                  // Strip implicit filters from agent-facing responses
+                  if (compiledModelDefinition.sources) {
+                     for (const source of compiledModelDefinition.sources) {
+                        if (source.filters) {
+                           source.filters = source.filters.filter(
+                              (f) => !f.implicit,
+                           );
+                        }
+                     }
+                  }
+
+                  return compiledModelDefinition;
                } catch (error) {
                   let errorDetails;
                   // Provide specific context for error messages

package/src/mcp/resources/source_resource.ts

@@ -2,8 +2,8 @@ import {
    McpServer,
    ResourceTemplate,
 } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { URL } from "url"; // Import URL
-import type { components } from "../../api"; // Need this for Source definition type
+import { URL } from "url";
+import type { components } from "../../api";
 import { ModelCompilationError } from "../../errors";
 import { logger } from "../../logger";
 import { ProjectStore } from "../../service/project_store";
@@ -89,22 +89,23 @@ export function registerSourceResource(
                   if (!sources) {
                      throw new Error("Could not retrieve sources from model.");
                   }
-                  // Add type annotation for 's'
                   const source = sources.find(
-                     // @ts-expect-error TODO: Fix missing Source type in API
                      (s: components["schemas"]["Source"]) =>
                         s.name === sourceName,
                   );
 
                   if (!source) {
-                     // Specific "Source not found" error
                      const errorDetails = getNotFoundError(
                         `Source '${sourceName}' in model '${modelPath}' package '${packageName}' project '${projectName}'`,
                      );
                      throw new McpGetResourceError(errorDetails);
                   }
 
-                  // Return the source definition
+                  // Strip implicit filters from agent-facing responses
+                  if (source.filters) {
+                     source.filters = source.filters.filter((f) => !f.implicit);
+                  }
+
                   return source;
                } catch (error) {
                   // Catch errors from getModelForQuery or finding the source

package/src/mcp/resources/view_resource.ts

@@ -83,7 +83,6 @@ export function registerViewResource(
                      throw new Error("Could not retrieve sources from model.");
                   }
                   const source = sources.find(
-                     // @ts-expect-error TODO: Fix missing Source type in API
                      (s: components["schemas"]["Source"]) =>
                         s.name === sourceName,
                   );