@malloy-publisher/server 0.0.235 → 0.0.236

package/tests/integration/mcp/mcp_execute_query_tool.integration.spec.ts

@@ -1,438 +0,0 @@
-// @ts-expect-error Bun test types are not recognized by ESLint
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
-import type {
-   Notification,
-   Request,
-   Result,
-} from "@modelcontextprotocol/sdk/types.js"; // Keep these base types
-import { ErrorCode } from "@modelcontextprotocol/sdk/types.js";
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import { URL } from "url";
-import { MCP_ERROR_MESSAGES } from "../../../src/mcp/mcp_constants"; // Keep for error message checks
-
-// --- Import E2E Test Setup ---
-import {
-   cleanupE2ETestEnvironment,
-   McpE2ETestEnvironment,
-   setupE2ETestEnvironment,
-} from "../../harness/mcp_test_setup";
-
-// --- Test Suite ---
-describe.serial("MCP Tool Handlers (E2E Integration)", () => {
-   let env: McpE2ETestEnvironment | null = null;
-   let mcpClient: Client;
-
-   const ENVIRONMENT_NAME = "examples";
-   const PACKAGE_NAME = "storefront";
-
-   beforeAll(async () => {
-      // Setup the E2E environment (starts server, connects client)
-      env = await setupE2ETestEnvironment();
-      mcpClient = env.mcpClient; // Assign client from setup
-   });
-
-   afterAll(async () => {
-      await cleanupE2ETestEnvironment(env);
-      env = null;
-   });
-
-   describe("malloy_executeQuery Tool", () => {
-      // Constants for test parameters
-
-      it(
-         "should execute a valid ad-hoc query successfully",
-         async () => {
-            if (!env) throw new Error("Test environment not initialized");
-            const result = await mcpClient.callTool({
-               name: "malloy_executeQuery",
-               arguments: {
-                  environmentName: ENVIRONMENT_NAME,
-                  packageName: PACKAGE_NAME,
-                  modelPath: "storefront.malloy",
-                  query: "run: order_items->{ aggregate: c is count() }",
-               },
-            });
-
-            expect(result).toBeDefined();
-            expect(result.isError).not.toBe(true); // Should be success
-            expect(result.content).toBeDefined();
-
-            const content = result.content as Array<{
-               type: string;
-               // eslint-disable-next-line @typescript-eslint/no-explicit-any
-               [key: string]: any;
-            }>;
-            expect(Array.isArray(content)).toBe(true);
-            // Expect 1 content block (result)
-            expect(content.length).toBe(1);
-
-            // Check structure of each block
-            for (const block of content) {
-               expect(block.type).toBe("resource");
-               expect(block.resource).toBeDefined();
-               expect(block.resource.mimeType).toBe("application/json");
-               expect(block.resource.text).toBeDefined();
-               expect(typeof block.resource.text).toBe("string");
-            }
-
-            // Basic check on the first block (result)
-
-            const queryResultBlock = content[0].resource;
-            expect(queryResultBlock.uri).toContain("#result");
-            const envelope = JSON.parse(queryResultBlock.text);
-
-            // Flat rows keyed by column name: the same shape an in-package data
-            // app receives, not the type-tagged Malloy cell envelope.
-            expect(Array.isArray(envelope.rows)).toBe(true);
-            expect(envelope.rows.length).toBeGreaterThan(0);
-            expect(typeof envelope.rows[0]).toBe("object");
-            expect(envelope.rows[0].data).toBeUndefined();
-
-            // Credible's field names, so an agent sees one shape whether the
-            // app is authored locally against Publisher or served in production.
-            expect(typeof envelope._query_row_limit).toBe("number");
-            expect(typeof envelope._limit_hit).toBe("boolean");
-            // Absent rather than false when nothing was dropped.
-            expect("_rows_truncated" in envelope).toBe(false);
-            // The metadata flat rows drop.
-            expect(envelope._meta.schema).toBeDefined();
-            expect(typeof envelope._meta.connection_name).toBe("string");
-         },
-         { timeout: 30000 },
-      );
-
-      it(
-         "should successfully execute a nested view using sourceName and queryName",
-         async () => {
-            if (!env) throw new Error("Test environment not initialized");
-            const params = {
-               environmentName: ENVIRONMENT_NAME,
-               packageName: PACKAGE_NAME,
-               modelPath: "storefront.malloy",
-               sourceName: "order_items", // Added sourceName
-               queryName: "top_products",
-            };
-
-            // Expect RESOLUTION with success
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const result: any = await mcpClient.callTool({
-               name: "malloy_executeQuery",
-               arguments: params,
-            });
-
-            expect(result).toBeDefined();
-            expect(result.isError).toBe(false); // Expecting success
-            expect(result.content).toBeDefined();
-            expect(Array.isArray(result.content)).toBe(true);
-            // Expect 1 content block (result)
-            expect(result.content.length).toBeGreaterThan(0);
-
-            // Check the structure of the first content block (result)
-            const queryResultBlock = result.content![0];
-            expect(queryResultBlock.type).toBe("resource");
-            expect(queryResultBlock.resource).toBeDefined();
-            expect(queryResultBlock.resource.mimeType).toBe("application/json");
-            expect(queryResultBlock.resource.uri).toMatch(/result/); // Check URI contains queryResult
-            expect(queryResultBlock.resource.text).toBeDefined();
-
-            // Optionally, parse and check the actual data
-            const queryResultPayload = JSON.parse(
-               queryResultBlock.resource.text,
-            );
-            expect(queryResultPayload).toBeDefined();
-            // Add more specific data checks if needed, e.g., check for specific columns or row count > 0
-            // Example: expect(queryResultPayload._queryResult.data.rows.length).toBeGreaterThan(0);
-         },
-         { timeout: 30000 },
-      );
-
-      it(
-         "should return application error for invalid Malloy query syntax",
-         async () => {
-            if (!env) throw new Error("Test environment not initialized");
-            const params = {
-               environmentName: ENVIRONMENT_NAME,
-               packageName: PACKAGE_NAME,
-               modelPath: "storefront.malloy",
-               query: "run: order_items->{BAD SYNTAX aggregate: order_count is count()}",
-            };
-
-            // Application Error (Malloy Compilation): Expect RESOLUTION with isError: true
-            // eslint-disable-next-line @typescript-eslint/no-explicit-any
-            const result: any = await mcpClient.callTool({
-               name: "malloy_executeQuery",
-               arguments: params,
-            });
-
-            expect(result.isError).toBe(true);
-            expect(result.content).toBeDefined();
-            // Check the new structure: resource -> application/json
-            const errorBlockSyntax = result.content![0];
-            expect(errorBlockSyntax.type).toBe("resource");
-            expect(errorBlockSyntax.resource).toBeDefined();
-            expect(errorBlockSyntax.resource.mimeType).toBe("application/json");
-
-            // Check for Malloy compilation error message from getMalloyErrorDetails
-            const errorJsonTextSyntax = errorBlockSyntax.resource
-               .text as string;
-            const errorPayloadSyntax = JSON.parse(errorJsonTextSyntax);
-            expect(errorPayloadSyntax.error).toMatch(
-               /syntax error|no viable alternative/i,
-            );
-            expect(Array.isArray(errorPayloadSyntax.suggestions)).toBe(true);
-
-            // The resource block is invisible to a client that renders only
-            // text on an isError result, which is how a real diagnostic gets
-            // reported as a bare "Unknown error". Pinned here, over the real
-            // HTTP transport, because the unit spec calls the handler directly
-            // and so cannot catch the block being dropped in serialization.
-            const textBlockSyntax = result.content!.find(
-               // eslint-disable-next-line @typescript-eslint/no-explicit-any
-               (b: any) => b.type === "text",
-            );
-            expect(textBlockSyntax?.text).toContain(errorPayloadSyntax.error);
-         },
-         { timeout: 30000 },
-      );
-
-      // --- Parameter Validation Error Tests ---
-      // These should RESOLVE with isError: true because the error is thrown
-      // inside the handler and caught by the transport bridge, which returns 200 OK + error payload.
-      it("should RESOLVE with InvalidParams for conflicting parameters (query and queryName)", async () => {
-         if (!env) throw new Error("Test environment not initialized");
-         const params = {
-            environmentName: ENVIRONMENT_NAME,
-            packageName: PACKAGE_NAME,
-            modelPath: "storefront.malloy",
-            query: "run: order_items->{aggregate: c is count()}",
-            queryName: "top_products",
-         };
-
-         // Expect RESOLUTION because the error is thrown *inside* the handler
-         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-         const result: any = await mcpClient.callTool({
-            name: "malloy_executeQuery",
-            arguments: params,
-         });
-
-         expect(result.isError).toBe(true);
-         expect(result.content).toBeDefined();
-         // Revert to expecting type: "text" for McpError caught by SDK
-         expect(result.content?.[0]?.type).toBe("text");
-         // Check the error message in the content
-         expect(result.content?.[0]?.text).toBe(
-            // Match the message including the prefix added by the client/framework
-            `MCP error ${ErrorCode.InvalidParams}: ${MCP_ERROR_MESSAGES.MUTUALLY_EXCLUSIVE_PARAMS}`,
-         );
-      });
-
-      it("should RESOLVE with InvalidParams if required params are missing (e.g., query or queryName)", async () => {
-         if (!env) throw new Error("Test environment not initialized");
-         const params = {
-            environmentName: ENVIRONMENT_NAME,
-            packageName: PACKAGE_NAME,
-            modelPath: "storefront.malloy",
-            // Missing query AND queryName
-         };
-
-         // Expect RESOLUTION because the error is thrown *inside* the handler
-         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-         const result: any = await mcpClient.callTool({
-            name: "malloy_executeQuery",
-            arguments: params,
-         });
-
-         expect(result.isError).toBe(true);
-         expect(result.content).toBeDefined();
-         // Revert to expecting type: "text" for McpError caught by SDK
-         expect(result.content?.[0]?.type).toBe("text");
-         // Check the error message in the content
-         expect(result.content?.[0]?.text).toBe(
-            // Match the message including the prefix added by the client/framework
-            `MCP error ${ErrorCode.InvalidParams}: ${MCP_ERROR_MESSAGES.MISSING_REQUIRED_PARAMS}`,
-         );
-      });
-
-      it("should reject with InvalidParams if required top-level params are missing (e.g., modelPath)", async () => {
-         if (!env) throw new Error("Test environment not initialized");
-         const params = {
-            // Missing modelPath
-            environmentName: ENVIRONMENT_NAME,
-            packageName: PACKAGE_NAME,
-            query: "run: order_items->{aggregate: c is count()}",
-         };
-
-         // Protocol Error (Caught by Zod/MCP): Expect REJECTION
-         await expect(
-            mcpClient.callTool({
-               name: "malloy_executeQuery",
-               arguments: params,
-            }),
-         ).rejects.toMatchObject({
-            code: ErrorCode.InvalidParams,
-            // Zod error message will likely mention the missing field 'modelPath'
-            message: expect.stringContaining("modelPath"),
-         });
-      });
-      // --- End Parameter Validation Error Tests ---
-
-      it("should return application error if package not found", async () => {
-         if (!env) throw new Error("Test environment not initialized");
-         const params = {
-            environmentName: ENVIRONMENT_NAME,
-            packageName: "nonexistent_package", // Use a package that doesn't exist
-            modelPath: "storefront.malloy",
-            query: "run: order_items->{aggregate: c is count()}",
-         };
-
-         // Application Error (Service Layer): Expect RESOLUTION with isError: true
-         // Cast to any
-         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-         const result: any = await mcpClient.callTool({
-            name: "malloy_executeQuery",
-            arguments: params,
-         });
-
-         expect(result.isError).toBe(true);
-         expect(result.content).toBeDefined();
-         // Check the new structure: resource -> application/json
-         const errorBlockPkgNotFound = result.content![0];
-         expect(errorBlockPkgNotFound.type).toBe("resource");
-         expect(errorBlockPkgNotFound.resource).toBeDefined();
-         expect(errorBlockPkgNotFound.resource.mimeType).toBe(
-            "application/json",
-         );
-
-         // Parse the JSON string from the resource text content
-         const errorJsonTextPkgNotFound = errorBlockPkgNotFound.resource
-            .text as string;
-         const errorPayloadPkgNotFound = JSON.parse(errorJsonTextPkgNotFound);
-
-         // Check the parsed error object
-         expect(errorPayloadPkgNotFound).toBeDefined();
-         expect(errorPayloadPkgNotFound.error).toBeDefined();
-         expect(errorPayloadPkgNotFound.suggestions).toBeDefined();
-         expect(Array.isArray(errorPayloadPkgNotFound.suggestions)).toBe(true);
-         expect(errorPayloadPkgNotFound.suggestions.length).toBeGreaterThan(0);
-
-         // Check the specific error message within the parsed object
-         const expectedErrorMessageNotFound = `Resource not found: package '${params.packageName}' in environment '${params.environmentName}'`;
-         expect(errorPayloadPkgNotFound.error).toEqual(
-            expectedErrorMessageNotFound,
-         );
-      });
-
-      it("should return application error if model not found within package", async () => {
-         if (!env) throw new Error("Test environment not initialized");
-         const params = {
-            environmentName: ENVIRONMENT_NAME,
-            packageName: PACKAGE_NAME,
-            modelPath: "nonexistent_model.malloy", // Use a model that doesn't exist
-            query: "run: order_items->{aggregate: c is count()}",
-         };
-
-         // Application Error (Service Layer): Expect RESOLUTION with isError: true
-         // Cast to any
-         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-         const result: any = await mcpClient.callTool({
-            name: "malloy_executeQuery",
-            arguments: params,
-         });
-
-         expect(result.isError).toBe(true);
-         expect(result.content).toBeDefined();
-         // Check the new structure: resource -> application/json
-         const errorBlockModel = result.content![0];
-         expect(errorBlockModel.type).toBe("resource");
-         expect(errorBlockModel.resource).toBeDefined();
-         expect(errorBlockModel.resource.mimeType).toBe("application/json");
-
-         // Parse the JSON string from the resource text content
-         const errorJsonTextModel = errorBlockModel.resource.text as string;
-         const errorPayloadModel = JSON.parse(errorJsonTextModel);
-
-         // Check the parsed error object
-         expect(errorPayloadModel).toBeDefined();
-         expect(errorPayloadModel.error).toBeDefined();
-         expect(errorPayloadModel.suggestions).toBeDefined();
-         expect(Array.isArray(errorPayloadModel.suggestions)).toBe(true);
-         expect(errorPayloadModel.suggestions.length).toBeGreaterThan(0);
-
-         // Check the specific error message within the parsed object
-         const expectedErrorMessageModel = `Resource not found: model '${params.modelPath}' in package '${params.packageName}' for environment '${params.environmentName}'`;
-         expect(errorPayloadModel.error).toEqual(expectedErrorMessageModel);
-
-         // Check for the specific model name and context in the message
-         expect(errorPayloadModel.error).toMatch(/Resource not found/i);
-      });
-
-      // Stateless HTTP + fast queries make true in-flight cancellation flaky
-      // (the response often completes before close wins the race). Assert the
-      // transport contract instead: a closed client cannot issue further tools.
-      it("should reject malloy_executeQuery after the MCP client is closed", async () => {
-         if (!env) throw new Error("Test environment not initialized");
-
-         const closedClient = new Client<Request, Notification, Result>({
-            name: "closed-client-test",
-            version: "1.0",
-         });
-         const transport = new StreamableHTTPClientTransport(
-            new URL(env.serverUrl + "/mcp"),
-         );
-         await closedClient.connect(transport);
-         await closedClient.close();
-
-         await expect(
-            closedClient.callTool({
-               name: "malloy_executeQuery",
-               arguments: {
-                  environmentName: ENVIRONMENT_NAME,
-                  packageName: PACKAGE_NAME,
-                  modelPath: "storefront.malloy",
-                  query: "run: order_items->{aggregate: c is count()}",
-               },
-            }),
-         ).rejects.toThrow();
-      });
-
-      // Test invalid usage - nested view called without sourceName
-      it("should return application error for nested view without sourceName", async () => {
-         if (!env) throw new Error("Test environment not initialized");
-         const params = {
-            environmentName: ENVIRONMENT_NAME,
-            packageName: PACKAGE_NAME,
-            modelPath: "storefront.malloy",
-            queryName: "top_products", // Nested view, but sourceName is missing
-         };
-
-         // Expect RESOLUTION with error because it's invalid usage processed by the handler
-         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-         const result: any = await mcpClient.callTool({
-            name: "malloy_executeQuery",
-            arguments: params,
-         });
-
-         expect(result).toBeDefined();
-         expect(result.isError).toBe(true); // Expecting error
-         expect(result.content).toBeDefined();
-         expect(Array.isArray(result.content)).toBe(true);
-         expect(result.content.length).toBeGreaterThan(0);
-
-         // Check the error structure: resource -> application/json
-         const errorBlock = result.content![0];
-         expect(errorBlock.type).toBe("resource");
-         expect(errorBlock.resource).toBeDefined();
-         expect(errorBlock.resource.mimeType).toBe("application/json");
-
-         // Check for Malloy error indicating the query/view wasn't found at the top level
-         const errorJsonText = errorBlock.resource.text as string;
-         const errorPayload = JSON.parse(errorJsonText);
-         // Expect error about the query/view itself not found
-         expect(errorPayload.error).toMatch(
-            /Query 'top_products' not found|Reference to undefined object 'top_products'/i,
-         );
-         expect(Array.isArray(errorPayload.suggestions)).toBe(true);
-      });
-   });
-});

package/tests/integration/mcp/mcp_get_context_semantic.integration.spec.ts

@@ -1,235 +0,0 @@
-import { afterAll, beforeAll, describe, expect, it } from "bun:test";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import {
-   Notification,
-   Request,
-   Result,
-} from "@modelcontextprotocol/sdk/types.js";
-import http from "http";
-import { AddressInfo } from "net";
-import {
-   McpE2ETestEnvironment,
-   cleanupE2ETestEnvironment,
-   setupE2ETestEnvironment,
-} from "../../harness/mcp_test_setup";
-
-/**
- * End-to-end coverage of semantic malloy_getContext retrieval: the real
- * server, the real DuckDB vector cache, and a deterministic in-test
- * embedding endpoint (letter-bigram bag-of-words vectors, so related
- * phrases genuinely land near each other, no network, no key).
- */
-
-const ENVIRONMENT_NAME = "examples";
-const PACKAGE_NAME = "storefront";
-const DIMS = 64;
-
-/** Deterministic unit vector from letter bigrams. */
-function bigramVector(text: string): number[] {
-   const v = new Array<number>(DIMS).fill(0);
-   const s = ` ${text.toLowerCase().replace(/[^a-z0-9]+/g, " ")} `;
-   for (let i = 0; i < s.length - 1; i++) {
-      v[(s.charCodeAt(i) * 31 + s.charCodeAt(i + 1)) % DIMS] += 1;
-   }
-   const norm = Math.sqrt(v.reduce((acc, x) => acc + x * x, 0)) || 1;
-   return v.map((x) => x / norm);
-}
-
-let env: McpE2ETestEnvironment | null = null;
-let mcpClient: Client<Request, Notification, Result>;
-let embeddingStub: http.Server;
-let stubFailing = false;
-let stubRequests = 0;
-
-const savedEnv: Record<string, string | undefined> = {};
-const ENV_KEYS = [
-   "EMBEDDING_API_KEY",
-   "EMBEDDING_API_BASE",
-   "EMBEDDING_MODEL",
-   "EMBEDDING_DIMENSIONS",
-];
-
-interface GetContextPayload {
-   retrieval?: string;
-   results?: Array<{
-      kind: string;
-      name: string;
-      source?: string;
-      score?: number;
-   }>;
-   error?: string;
-}
-
-async function callGetContext(
-   args: Record<string, unknown>,
-): Promise<GetContextPayload> {
-   const result = (await mcpClient.callTool({
-      name: "malloy_getContext",
-      arguments: args,
-   })) as {
-      content: Array<{ type: string; resource?: { text?: string } }>;
-   };
-   const text = result.content?.[0]?.resource?.text;
-   if (!text) throw new Error("malloy_getContext returned no resource text");
-   return JSON.parse(text) as GetContextPayload;
-}
-
-describe.serial("MCP getContext semantic retrieval (E2E Integration)", () => {
-   beforeAll(async () => {
-      // A local OpenAI-compatible /embeddings endpoint with deterministic
-      // vectors. Bound to 127.0.0.1:0; the real port comes from the OS.
-      embeddingStub = http.createServer((req, res) => {
-         let body = "";
-         req.on("data", (chunk) => (body += chunk));
-         req.on("end", () => {
-            stubRequests++;
-            if (stubFailing) {
-               res.writeHead(500).end("stub down");
-               return;
-            }
-            const { input } = JSON.parse(body) as { input: string[] };
-            res.writeHead(200, { "Content-Type": "application/json" }).end(
-               JSON.stringify({
-                  data: input.map((text, index) => ({
-                     index,
-                     embedding: bigramVector(text),
-                  })),
-               }),
-            );
-         });
-      });
-      await new Promise<void>((resolve) =>
-         embeddingStub.listen(0, "127.0.0.1", resolve),
-      );
-      const port = (embeddingStub.address() as AddressInfo).port;
-
-      // Set the embedding env vars BEFORE the server harness dynamically
-      // imports src/server; config is read per call, but this keeps the
-      // whole server lifetime consistently configured.
-      for (const key of ENV_KEYS) {
-         savedEnv[key] = process.env[key];
-      }
-      process.env.EMBEDDING_API_KEY = "integration-test-key";
-      process.env.EMBEDDING_API_BASE = `http://127.0.0.1:${port}/v1`;
-      // A stub-distinct model name: the suite shares publisher.db with
-      // local manual runs, and rows cached under the real default model
-      // name would poison a later real-provider run (the stub's bigram
-      // vectors are not text-embedding-3-small's). Under this name the
-      // leftovers are inert; a real run's model diff replaces them.
-      process.env.EMBEDDING_MODEL = "integration-test-bigram-stub";
-      delete process.env.EMBEDDING_DIMENSIONS;
-
-      env = await setupE2ETestEnvironment();
-      mcpClient = env.mcpClient;
-   }, 200000);
-
-   afterAll(async () => {
-      await cleanupE2ETestEnvironment(env);
-      env = null;
-      // Restore the embedding env so later suites in this process run
-      // unconfigured (the provider getter re-reads env per call).
-      for (const key of ENV_KEYS) {
-         if (savedEnv[key] === undefined) delete process.env[key];
-         else process.env[key] = savedEnv[key];
-      }
-      await new Promise<void>((resolve, reject) =>
-         embeddingStub.close((err) => (err ? reject(err) : resolve())),
-      );
-   });
-
-   it(
-      "answers lexically while indexing, then flips to semantic with scores",
-      async () => {
-         const first = await callGetContext({
-            environmentName: ENVIRONMENT_NAME,
-            packageName: PACKAGE_NAME,
-            query: "total sales revenue",
-         });
-         // Configured server: the marker is always present on tier 4.
-         expect(["lexical", "semantic"]).toContain(first.retrieval);
-
-         let payload = first;
-         for (let i = 0; i < 60 && payload.retrieval !== "semantic"; i++) {
-            await new Promise((resolve) => setTimeout(resolve, 500));
-            payload = await callGetContext({
-               environmentName: ENVIRONMENT_NAME,
-               packageName: PACKAGE_NAME,
-               query: "total sales revenue",
-            });
-         }
-         expect(payload.retrieval).toBe("semantic");
-         expect(stubRequests).toBeGreaterThan(0);
-
-         const results = payload.results ?? [];
-         expect(results.length).toBeGreaterThan(0);
-         for (const r of results) {
-            expect(typeof r.score).toBe("number");
-         }
-         // The bigram embedding puts "total sales revenue" on top of the
-         // total_sales measure ("total sales" once humanized).
-         expect(results.some((r) => r.name === "total_sales")).toBe(true);
-      },
-      { timeout: 60000 },
-   );
-
-   it(
-      "keeps the semantic index warm across calls (no re-embed per call)",
-      async () => {
-         const before = stubRequests;
-         const payload = await callGetContext({
-            environmentName: ENVIRONMENT_NAME,
-            packageName: PACKAGE_NAME,
-            query: "orders by month",
-         });
-         expect(payload.retrieval).toBe("semantic");
-         // Exactly one stub call: the query embedding. No bulk re-sync.
-         expect(stubRequests).toBe(before + 1);
-      },
-      { timeout: 30000 },
-   );
-
-   it(
-      "narrows semantic retrieval with sourceName",
-      async () => {
-         const payload = await callGetContext({
-            environmentName: ENVIRONMENT_NAME,
-            packageName: PACKAGE_NAME,
-            query: "total sales revenue",
-            sourceName: "order_items",
-         });
-         expect(payload.retrieval).toBe("semantic");
-         const results = payload.results ?? [];
-         // Non-empty, or the per-result loop below pins nothing.
-         expect(results.length).toBeGreaterThan(0);
-         for (const r of results) {
-            expect(r.source).toBe("order_items");
-         }
-      },
-      { timeout: 30000 },
-   );
-
-   // Keep this test LAST: the induced failure starts the provider
-   // cool-down, which short-circuits the semantic path for its window.
-   it(
-      "falls back to lexical, marked, when the embedding endpoint fails",
-      async () => {
-         stubFailing = true;
-         try {
-            const payload = await callGetContext({
-               environmentName: ENVIRONMENT_NAME,
-               packageName: PACKAGE_NAME,
-               query: "top selling products",
-            });
-            expect(payload.retrieval).toBe("lexical");
-            const results = payload.results ?? [];
-            expect(results.length).toBeGreaterThan(0);
-            for (const r of results) {
-               expect(r.score).toBeUndefined();
-            }
-         } finally {
-            stubFailing = false;
-         }
-      },
-      { timeout: 30000 },
-   );
-});