@malloy-publisher/server 0.0.227 → 0.0.228

package/src/mcp/tools/reload_package_tool.spec.ts

@@ -0,0 +1,232 @@
+import { describe, expect, it } from "bun:test";
+import { registerReloadPackageTool } from "./reload_package_tool";
+import type { EnvironmentStore } from "../../service/environment_store";
+import { PackageNotFoundError, ServiceUnavailableError } from "../../errors";
+
+// Capture the handler registerReloadPackageTool passes to McpServer.tool, so it
+// can be exercised against a mocked EnvironmentStore. The tool builds a
+// PackageController internally, which calls environment.getPackage(pkg, reload),
+// so the mock only needs getEnvironment -> { getPackage }.
+type Handler = (params: Record<string, unknown>) => Promise<{
+   isError?: boolean;
+   content: Array<{ resource: { text: string } }>;
+}>;
+
+function captureHandler(store: Partial<EnvironmentStore>): Handler {
+   let handler: Handler | undefined;
+   const fakeServer = {
+      tool: (_name: string, _desc: string, _shape: unknown, h: Handler) => {
+         handler = h;
+      },
+   };
+   registerReloadPackageTool(fakeServer as never, store as EnvironmentStore);
+   if (!handler) throw new Error("handler was not registered");
+   return handler;
+}
+
+function parse(result: { content: Array<{ resource: { text: string } }> }) {
+   return JSON.parse(result.content[0].resource.text);
+}
+
+// A store whose package reload returns `metadata`. `location` is left undefined
+// so PackageController takes the in-place-reload branch (no re-download). The
+// optional `calls` array records the `reload` flag of every getPackage call.
+function storeReturning(
+   metadata: Record<string, unknown>,
+   calls?: boolean[],
+): Partial<EnvironmentStore> {
+   return {
+      getEnvironment: async () =>
+         ({
+            getPackage: async (_pkg: string, reload: boolean) => {
+               calls?.push(reload);
+               return { getPackageMetadata: () => metadata } as never;
+            },
+         }) as never,
+   };
+}
+
+// A store whose cached package metadata carries `location`, so PackageController
+// takes the re-fetch branch: installPackage instead of an in-place recompile.
+// This is the only remaining path that overwrites on-disk edits, so it is worth
+// pinning that the routing and the reported mode both match.
+function storeWithInstallLocation(installed: Record<string, unknown>): {
+   store: Partial<EnvironmentStore>;
+   installCalls: string[];
+} {
+   const installCalls: string[] = [];
+   return {
+      installCalls,
+      store: {
+         getEnvironment: async () =>
+            ({
+               getPackage: async () =>
+                  ({
+                     getPackageMetadata: () => ({
+                        name: "ecommerce",
+                        location: "https://github.com/example/pkg",
+                     }),
+                  }) as never,
+               installPackage: async (pkg: string) => {
+                  installCalls.push(pkg);
+                  return { getPackageMetadata: () => installed } as never;
+               },
+            }) as never,
+      },
+   };
+}
+
+const args = { environmentName: "malloy-samples", packageName: "ecommerce" };
+
+describe("malloy_reloadPackage tool", () => {
+   it("returns status reloaded with the package name", async () => {
+      const handler = captureHandler(storeReturning({ name: "ecommerce" }));
+      const result = await handler(args);
+      expect(result.isError).toBe(false);
+      expect(parse(result)).toEqual({
+         status: "reloaded",
+         mode: "in-place",
+         name: "ecommerce",
+      });
+   });
+
+   it("includes description and non-empty warnings", async () => {
+      const warnings = [
+         {
+            model: "ecommerce.malloy",
+            target: "top_categories",
+            severity: "error",
+         },
+      ];
+      const handler = captureHandler(
+         storeReturning({ name: "ecommerce", description: "shop", warnings }),
+      );
+      const parsed = parse(await handler(args));
+      expect(parsed).toEqual({
+         status: "reloaded",
+         mode: "in-place",
+         name: "ecommerce",
+         description: "shop",
+         warnings,
+      });
+   });
+
+   it("omits warnings when the reloaded package has none", async () => {
+      const handler = captureHandler(
+         storeReturning({ name: "ecommerce", warnings: [] }),
+      );
+      const parsed = parse(await handler(args));
+      expect(parsed.warnings).toBeUndefined();
+      expect(parsed.status).toBe("reloaded");
+   });
+
+   it("forwards reload=true (recompiles, not just reads)", async () => {
+      const calls: boolean[] = [];
+      const handler = captureHandler(
+         storeReturning({ name: "ecommerce" }, calls),
+      );
+      await handler(args);
+      // The controller probes cached metadata (reload=false) then reloads
+      // (reload=true); the tool must trigger the recompile.
+      expect(calls).toContain(true);
+   });
+
+   it("surfaces a thrown error as a tool error, not a transport fault", async () => {
+      const handler = captureHandler({
+         getEnvironment: async () => {
+            throw new Error("Environment 'nope' could not be resolved");
+         },
+      });
+      const result = await handler({ ...args, environmentName: "nope" });
+      expect(result.isError).toBe(true);
+      expect(parse(result).error).toBeDefined();
+   });
+
+   it("reports a missing package as not-found, not as a Malloy syntax problem", async () => {
+      // Pin the remediation text, not just that an error came back. Asserting
+      // only that `error` is defined is what let every error class funnel
+      // through the Malloy helper unnoticed: a typo'd package name told the
+      // caller to go check its Malloy syntax.
+      const handler = captureHandler({
+         getEnvironment: async () => {
+            throw new PackageNotFoundError("Package 'nope' not found");
+         },
+      });
+      const parsed = parse(await handler({ ...args, packageName: "nope" }));
+      expect(parsed.error).toContain("Resource not found");
+      expect(JSON.stringify(parsed.suggestions)).not.toContain("Malloy file");
+   });
+
+   it("reports back-pressure as retryable, not as a Malloy syntax problem", async () => {
+      const handler = captureHandler({
+         getEnvironment: async () => {
+            throw new ServiceUnavailableError("Memory limit reached");
+         },
+      });
+      const parsed = parse(await handler(args));
+      expect(parsed.error).toContain("Memory limit reached");
+      expect(JSON.stringify(parsed.suggestions)).toContain("Retry");
+      expect(JSON.stringify(parsed.suggestions)).not.toContain("Malloy file");
+   });
+
+   it("surfaces a hard compile failure on reload as a tool error", async () => {
+      // A Package.create compile failure propagates out of environment.getPackage
+      // (the reload site), not out of getEnvironment. The controller swallows the
+      // first probe call and re-throws on the reload call.
+      const handler = captureHandler({
+         getEnvironment: async () =>
+            ({
+               getPackage: async () => {
+                  throw new Error("'nonexistent_status_field' is not defined");
+               },
+            }) as never,
+      });
+      const result = await handler(args);
+      expect(result.isError).toBe(true);
+      expect(parse(result).error).toBeDefined();
+   });
+
+   it("reports mode in-place for a package with no install location", async () => {
+      const handler = captureHandler(storeReturning({ name: "ecommerce" }));
+      expect(parse(await handler(args)).mode).toBe("in-place");
+   });
+
+   it("re-fetches and reports mode reinstalled when the package carries an install location", async () => {
+      // The one path that still overwrites on-disk edits. It must route through
+      // installPackage, and the payload must say so, since an agent cannot
+      // otherwise tell that its saved edit was just re-fetched over.
+      const { store, installCalls } = storeWithInstallLocation({
+         name: "ecommerce",
+         location: "https://github.com/example/pkg",
+      });
+      const handler = captureHandler(store);
+      const result = await handler(args);
+      expect(result.isError).toBe(false);
+      expect(installCalls).toEqual(["ecommerce"]);
+      expect(parse(result).mode).toBe("reinstalled");
+   });
+
+   it("never echoes the package location back to the caller", async () => {
+      // The payload hand-picks fields; REST spreads the whole ApiPackage. Pin
+      // that the allowlist holds, since location is the one field here that is
+      // deployment detail rather than something an agent needs.
+      const { store } = storeWithInstallLocation({
+         name: "ecommerce",
+         location: "https://github.com/example/pkg",
+      });
+      const parsed = parse(await captureHandler(store)(args));
+      expect(parsed.location).toBeUndefined();
+   });
+
+   it("surfaces exploresWarnings (a mistyped explores entry is not swallowed)", async () => {
+      const exploresWarnings = [
+         "explore 'ordrs' does not resolve to a model in this package",
+      ];
+      const handler = captureHandler(
+         storeReturning({ name: "ecommerce", exploresWarnings }),
+      );
+      const parsed = parse(await handler(args));
+      expect(parsed.status).toBe("reloaded");
+      expect(parsed.exploresWarnings).toEqual(exploresWarnings);
+   });
+});

package/src/mcp/tools/reload_package_tool.ts

@@ -0,0 +1,158 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod";
+import { logger } from "../../logger";
+import { EnvironmentStore } from "../../service/environment_store";
+import { PackageController } from "../../controller/package.controller";
+import { type ErrorDetails } from "../error_messages";
+import { buildMalloyUri, classifyToolError } from "../handler_utils";
+
+// Zod shape for malloy_reloadPackage. environmentName/packageName mirror the
+// other tools and point the agent at malloy_getContext for name discovery.
+const reloadShape = {
+   environmentName: z
+      .string()
+      .describe(
+         "Environment name. Call malloy_getContext with no arguments to list the available environments.",
+      ),
+   packageName: z
+      .string()
+      .describe(
+         "Package to reload. Call malloy_getContext with just environmentName to list its packages.",
+      ),
+};
+
+/**
+ * What a failed reload does, in one sentence, shared with MCP_INSTRUCTIONS
+ * rather than restated there. Both surfaces describe the same behavior, so one
+ * copy is what stops them drifting.
+ *
+ * SECURITY: interpolated into MCP_INSTRUCTIONS, which is delivered
+ * pre-authorization to any connecting client. Keep this a static string
+ * literal; never derive it from config, environment, or request data.
+ */
+export const RELOAD_FAILURE_IS_SAFE =
+   "A reload that fails to compile leaves your files on disk alone and keeps serving the previously compiled model, returning the compile errors.";
+
+const RELOAD_DESCRIPTION = `Reload a package so edits to its model files on disk are picked up, making newly added or changed sources, views, and named queries resolvable by malloy_executeQuery WITHOUT restarting the server. Publisher compiles each configured package at boot and serves that cached model, so a source or view you add afterwards is not queryable by name until the package is reloaded. Use this to close the edit -> run loop after saving a model change.
+
+${RELOAD_FAILURE_IS_SAFE} Running malloy_compile first is still the faster way to see diagnostics, and it keeps a broken model from ever reaching the reload.
+
+## Parameters
+- environmentName, packageName (required): the package to recompile. Use the names malloy_getContext returns.
+
+## Behavior
+Recompiles the package from its current on-disk content under publisher_data/, so your saved edits are picked up. This is the path every package from publisher.config.json takes. A package whose stored metadata carries an install location (only a PATCH that supplies one sets it) is re-fetched from that source instead, which overwrites on-disk edits.
+
+## Response
+A JSON object with status "reloaded", a mode of "in-place" or "reinstalled", the package name, any render-tag warnings, and any exploresWarnings (curated-discovery entries that did not resolve to a model). Check mode if you had unsaved-elsewhere edits on disk: "in-place" recompiled them, "reinstalled" re-fetched over them. A reload that hits a hard compile error returns an error payload instead.`;
+
+/**
+ * Registers the malloy_reloadPackage MCP tool: recompiles a package from its
+ * on-disk content so a saved model edit becomes queryable by name without a
+ * server restart. Wraps the same PackageController.getPackage(reload=true) path
+ * the REST GET /environments/:env/packages/:pkg?reload=true endpoint uses, so it
+ * adds no capability beyond that already-exposed endpoint (SECURITY: parity with
+ * REST. The MCP surface is unauthenticated, and so is that endpoint; a reload
+ * mutates the shared in-memory package but returns only names and warnings,
+ * never row data or the package's location).
+ */
+export function registerReloadPackageTool(
+   mcpServer: McpServer,
+   environmentStore: EnvironmentStore,
+): void {
+   const packageController = new PackageController(environmentStore);
+
+   mcpServer.tool(
+      "malloy_reloadPackage",
+      RELOAD_DESCRIPTION,
+      reloadShape,
+      async (params) => {
+         const { environmentName, packageName } = params;
+
+         logger.info("[MCP Tool reloadPackage] Reloading package", {
+            environmentName,
+            packageName,
+         });
+
+         const uri = buildMalloyUri(
+            { environment: environmentName, package: packageName },
+            "reloadPackage",
+         );
+
+         try {
+            const { metadata: pkg, mode } =
+               await packageController.reloadPackage(
+                  environmentName,
+                  packageName,
+               );
+
+            const payload = {
+               status: "reloaded" as const,
+               // Which path ran. "in-place" recompiled the tree on disk and left
+               // it alone; "reinstalled" re-fetched from the package's install
+               // location, so any on-disk edits are gone. The caller cannot tell
+               // these apart otherwise, and only one of them keeps their work.
+               mode,
+               name: pkg.name,
+               ...(pkg.description !== undefined && {
+                  description: pkg.description,
+               }),
+               ...(pkg.warnings !== undefined &&
+                  pkg.warnings.length > 0 && { warnings: pkg.warnings }),
+               // exploresWarnings is a distinct signal from render-tag warnings:
+               // it flags a curated-discovery (explores) entry that did not
+               // resolve to a model, so a mistyped explores edit is not silently
+               // swallowed on reload.
+               ...(pkg.exploresWarnings !== undefined &&
+                  pkg.exploresWarnings.length > 0 && {
+                     exploresWarnings: pkg.exploresWarnings,
+                  }),
+            };
+
+            return {
+               isError: false,
+               content: [
+                  {
+                     type: "resource" as const,
+                     resource: {
+                        type: "application/json",
+                        uri,
+                        text: JSON.stringify(payload),
+                     },
+                  },
+               ],
+            };
+         } catch (error) {
+            // Unknown environment/package, or a compile error in the reloaded
+            // package: surface as a clean isError payload rather than a
+            // transport fault.
+            logger.warn("[MCP Tool reloadPackage] reload failed", {
+               environmentName,
+               packageName,
+               error: error instanceof Error ? error.message : String(error),
+            });
+            const errorDetails: ErrorDetails = classifyToolError(
+               "reloadPackage",
+               `${environmentName}/${packageName}`,
+               error,
+            );
+            return {
+               isError: true,
+               content: [
+                  {
+                     type: "resource" as const,
+                     resource: {
+                        type: "application/json",
+                        uri,
+                        text: JSON.stringify({
+                           error: errorDetails.message,
+                           suggestions: errorDetails.suggestions,
+                        }),
+                     },
+                  },
+               ],
+            };
+         }
+      },
+   );
+}

package/src/runtime/publisher.js

@@ -5,6 +5,10 @@
 // Exposes window.Publisher with:
 //   - Publisher.query(model, malloy, opts?)     → Promise<rows[]>
 //   - Publisher.queryFull(model, malloy, opts?) → Promise<MalloyResult>  (envelope for <malloy-render>)
+//       opts: { environment?, package?, sourceName?, queryName?, filterParams?,
+//               bypassFilters?, givens? }. givens is a name→value map bound as
+//               Malloy given: runtime parameters for this query (safe parameterization,
+//               not string interpolation) — see the malloy-html-data-app-runtime skill.
 //   - Publisher.embed(selector, { src, height?, token? })
 //   - Publisher.context  ({ environment, package } inferred from URL)
 //   - Publisher.setToken(token)  (override Bearer token; default uses cookies)
@@ -92,6 +96,7 @@
       if (opts.queryName) body.queryName = opts.queryName;
       if (opts.filterParams) body.filterParams = opts.filterParams;
       if (opts.bypassFilters) body.bypassFilters = true;
+      if (opts.givens) body.givens = opts.givens;
 
       var headers = Object.assign(
          { "content-type": "application/json" },

package/src/server.ts

@@ -102,7 +102,7 @@ function parseArgs() {
             "  --port <number>        Port to run the server on (default: 4000)",
          );
          console.log(
-            "  --host <string>        Host to bind the server to (default: localhost)",
+            "  --host <string>        Host to bind the REST and MCP servers to (default: 0.0.0.0)",
          );
          console.log(
             "  --server_root <path>   Root directory to serve files from (default: .)",
@@ -120,7 +120,7 @@ function parseArgs() {
             "  --shutdown_graceful_close_timeout_seconds <number>  Time in seconds to wait after closing servers before exit (default: 0)",
          );
          console.log(
-            "  --init                 Initialize the storage (default: false)",
+            "  --init                 Wipe persisted storage and re-sync it from the config (default: false)",
          );
          console.log(
             "  --watch-env <name>     Enable dev-mode watch for the named environment.",
@@ -147,7 +147,7 @@ function parseArgs() {
    // this — the user told us where to look. Skip in NODE_ENV=test as a
    // belt-and-suspenders so any spec that ends up evaluating this
    // module doesn't accidentally pin the EnvironmentStore to the
-   // bundled malloy-samples config.
+   // bundled examples config.
    if (!sawServerRoot && !sawConfig && process.env.NODE_ENV !== "test") {
       process.env.PUBLISHER_USE_BUNDLED_DEFAULT = "true";
    }
@@ -1613,13 +1613,15 @@ app.get(
 );
 
 app.post(
-   `${API_PREFIX}/environments/:environmentName/packages/:packageName/models/:modelName/compile`,
+   `${API_PREFIX}/environments/:environmentName/packages/:packageName/models/*?/compile`,
    async (req, res) => {
       try {
+         // Express stores wildcard matches in params['0'], so nested model
+         // paths (models in subdirectories) compile just like they query.
          const result = await compileController.compile(
             req.params.environmentName,
             req.params.packageName,
-            req.params.modelName,
+            (req.params as Record<string, string>)["0"],
             req.body.source,
             req.body.includeSql === true,
             req.body.givens as Record<string, GivenValue> | undefined,

package/src/service/environment.ts

@@ -471,9 +471,30 @@ export class Environment {
             if (includeSql && queryMaterializer) {
                try {
                   sql = await queryMaterializer.getSQL({ givens });
-               } catch {
-                  // Source may not contain a runnable query (e.g. only source definitions),
-                  // in which case we simply omit the sql field.
+               } catch (error) {
+                  // A bad caller given (unknown name, wrong-typed value, finalized
+                  // override, ...) surfaces as a Malloy `runtime-given-*` error.
+                  // Map it to a 400 rather than silently omitting `sql` (which is
+                  // indistinguishable from "no runnable query"). Duck-type on
+                  // `.code`; let a MalloyError fall to the outer catch → problems.
+                  // The `runtime-given-` prefix is pinned to Malloy's error codes
+                  // (given_binding.ts / runtime.ts, same as model.ts) — if they're
+                  // renamed upstream a bad given would silently revert to the omit
+                  // branch below, so keep the two in sync.
+                  const givenCode = (error as { code?: string })?.code;
+                  if (
+                     typeof givenCode === "string" &&
+                     givenCode.startsWith("runtime-given-")
+                  ) {
+                     throw new BadRequestError(
+                        error instanceof Error ? error.message : String(error),
+                     );
+                  }
+                  if (error instanceof MalloyError) {
+                     throw error;
+                  }
+                  // Otherwise the source may just not contain a runnable query
+                  // (e.g. only source definitions) — omit the sql field.
                }
             }
 
@@ -860,8 +881,17 @@ export class Environment {
          return _package;
       } catch (error) {
          logger.error(`Failed to load package ${packageName}`, { error });
-         this.packages.delete(packageName);
-         this.packageStatuses.delete(packageName);
+         if (existingPackage !== undefined && reload) {
+            // A failed RELOAD must not take down a package that is already
+            // serving. The compiled model in `packages` is still the last good
+            // one (it is only replaced on success), so keep serving it and let
+            // the caller surface the error instead of evicting the package and
+            // leaving the environment with nothing to answer from.
+            this.setPackageStatus(packageName, PackageStatus.SERVING);
+         } else {
+            this.packages.delete(packageName);
+            this.packageStatuses.delete(packageName);
+         }
          throw error;
       }
    }
@@ -1019,6 +1049,10 @@ export class Environment {
                packageName,
                canonicalPath,
                () => this.malloyConfig.malloyConfig,
+               // This tree was just staged into place by the rename above, so a
+               // failed load leaves a half-built directory that is ours to
+               // remove; the rollback below restores the previous one.
+               true,
             );
             // Strict-reject hook (publish/update only — reload passes no
             // validator and stays fail-safe). Throw INSIDE the try so the
@@ -1064,7 +1098,37 @@ export class Environment {
             await fs.promises
                .rm(stagingPath, { recursive: true, force: true })
                .catch(() => {});
-            this.deletePackageStatus(packageName);
+            if (oldPackage && restored) {
+               // The rollback put the old tree back and the previous package is
+               // still in `this.packages` (it is only replaced on success
+               // below), so it is genuinely still serving. Deleting its status
+               // would strand it: listPackages enumerates packageStatuses, so
+               // the package would answer getPackage while being invisible to
+               // listings and discovery until a restart.
+               this.setPackageStatus(packageName, PackageStatus.SERVING);
+            } else {
+               // Either there was nothing to fall back to (a first install), or
+               // the restore did not happen: the rename-back threw, or the old
+               // tree was never on disk to retire. The canonical path is then
+               // missing or still holds the rejected content, so the cached
+               // package no longer matches disk and must not be advertised as
+               // serving. Drop both, and keep the two maps agreeing.
+               this.deletePackageStatus(packageName);
+               if (oldPackage) {
+                  // Retire before dropping it, the same way every other eviction
+                  // here does: once it leaves this.packages, closeAllConnections
+                  // can no longer reach its MalloyConfig, so its native handles
+                  // would never be released. Retire rather than shut down
+                  // inline, because withPackageLock does not cover queries that
+                  // already took this Package from an earlier getPackage; the
+                  // drain lets those finish first.
+                  this.retireConnectionGeneration(
+                     `package ${packageName}`,
+                     () => oldPackage.getMalloyConfig().shutdown("close"),
+                  );
+               }
+               this.packages.delete(packageName);
+            }
             logger.debug("install.phase2.rollback", {
                environmentName: this.environmentName,
                packageName,

package/src/service/model.spec.ts

@@ -444,6 +444,55 @@ describe("service/model", () => {
             sinon.restore();
          });
 
+         it("maps a finalized-given rejection (code) to BadRequestError, not 500", async () => {
+            // Malloy throws this (extends Error, not MalloyError, not root-exported)
+            // when a client supplies a given an operator finalized. model.ts
+            // duck-types on `.code`; guard against that mapping regressing.
+            const finalizedErr = Object.assign(
+               new Error(
+                  "Given 'region' is finalized and cannot be overridden",
+               ),
+               { code: "runtime-given-finalized" },
+            );
+            const runnableStub = {
+               getPreparedResult: sinon.stub().rejects(finalizedErr),
+               run: sinon.stub(),
+            };
+            const modelMaterializer = {
+               loadQuery: sinon.stub().returns(runnableStub),
+               loadRestrictedQuery: sinon.stub().returns(runnableStub),
+            };
+
+            const model = new Model(
+               packageName,
+               mockModelPath,
+               {},
+               "model",
+               // eslint-disable-next-line @typescript-eslint/no-explicit-any
+               modelMaterializer as any,
+               // eslint-disable-next-line @typescript-eslint/no-explicit-any
+               { contents: {}, exports: [], queryList: [] } as any,
+               undefined,
+               undefined,
+               undefined,
+               undefined,
+               undefined,
+            );
+
+            await expect(
+               model.getQueryResults(
+                  undefined,
+                  undefined,
+                  "run: orders -> summary",
+                  undefined,
+                  undefined,
+                  { region: "EU" },
+               ),
+            ).rejects.toThrow(BadRequestError);
+
+            sinon.restore();
+         });
+
          /**
           * The row/byte caps live in `model_limits.ts` (unit-tested in
           * `model_limits.spec.ts`); these tests just confirm the wiring —
@@ -684,6 +733,49 @@ describe("service/model", () => {
             sinon.restore();
          });
 
+         it("maps a finalized-given rejection (code) to BadRequestError, not 500", async () => {
+            const finalizedErr = Object.assign(
+               new Error(
+                  "Given 'target_code' is finalized and cannot be overridden",
+               ),
+               { code: "runtime-given-finalized" },
+            );
+            const cellRunnable = {
+               getPreparedResult: sinon.stub().rejects(finalizedErr),
+               run: sinon.stub(),
+            };
+            const runnableCells = [
+               {
+                  type: "code" as const,
+                  text: "run: orders -> by_code",
+                  runnable: cellRunnable,
+               },
+            ];
+
+            const model = new Model(
+               packageName,
+               "test.malloynb",
+               {},
+               "notebook",
+               undefined,
+               undefined,
+               undefined,
+               undefined,
+               undefined,
+               // eslint-disable-next-line @typescript-eslint/no-explicit-any
+               runnableCells as any,
+               undefined,
+            );
+
+            await expect(
+               model.executeNotebookCell(0, undefined, undefined, {
+                  target_code: "AA",
+               }),
+            ).rejects.toThrow(BadRequestError);
+
+            sinon.restore();
+         });
+
          it("embeds model-level givens in executed cell newSources", async () => {
             const sourceInfo = { name: "carriers", schema: { fields: [] } };
             const givens = [