@malloy-publisher/server 0.0.225 → 0.0.227

package/src/mcp/resources/environment_resource.ts

@@ -1,187 +0,0 @@
-import {
-   McpServer,
-   ResourceTemplate,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import type { ListResourcesResult } from "@modelcontextprotocol/sdk/types.js"; // Needed for list return type
-import { logger } from "../../logger";
-import { EnvironmentStore } from "../../service/environment_store";
-import { getInternalError, getNotFoundError } from "../error_messages"; // Needed for error handling in list AND get
-import { handleResourceGet, McpGetResourceError } from "../handler_utils";
-import { RESOURCE_METADATA } from "../resource_metadata";
-
-// Define an interface for the package object augmented with environment name
-interface PackageWithEnvironment {
-   name?: string;
-   // Add other relevant package properties if needed
-   environmentName: string;
-}
-
-/**
- * Registers the Malloy environment resource type with the MCP server (URI scheme malloy://environment/...).
- * Lists packages across environments and resolves environment metadata on read.
- */
-export function registerEnvironmentResource(
-   mcpServer: McpServer,
-   environmentStore: EnvironmentStore,
-): void {
-   mcpServer.resource(
-      "environment",
-      new ResourceTemplate("malloy://environment/{environmentName}", {
-         /**
-          * Handles ListResources requests.
-          * If environmentName is specified, lists packages for that environment (only 'home' supported).
-          * If environmentName is not specified (general ListResources call), lists packages for the default 'home' environment.
-          */
-         list: async (/* extra: ListEnvironmentExtra - Deleted */): Promise<ListResourcesResult> => {
-            logger.info(
-               "[MCP LOG] Entering ListResources (environment) handler (listing ALL packages)...",
-            );
-            // Ignore parameters from 'extra' as URI path params aren't passed to list handlers.
-
-            try {
-               const allEnvironments =
-                  await environmentStore.listEnvironments();
-               logger.info(
-                  `[MCP LOG] Found ${allEnvironments.length} environments defined.`,
-               );
-
-               const packagePromises = allEnvironments.map(async (env) => {
-                  try {
-                     logger.info(
-                        `[MCP LOG] Getting environment '${env.name}' to list its packages...`,
-                     );
-                     const environmentInstance =
-                        await environmentStore.getEnvironment(env.name!, false);
-                     const packages = await environmentInstance.listPackages();
-                     logger.info(
-                        `[MCP LOG] Found ${packages.length} packages in environment '${env.name}'.`,
-                     );
-                     // Return packages along with their environment name for URI construction
-                     return packages.map((pkg) => ({
-                        ...pkg,
-                        environmentName: env.name,
-                     }));
-                  } catch (environmentError) {
-                     logger.error(
-                        `[MCP Server Error] Error getting/listing packages for environment ${env.name}:`,
-                        { error: environmentError },
-                     );
-                     return []; // Return empty array for this environment on error
-                  }
-               });
-
-               const results = await Promise.allSettled(packagePromises);
-               const allPackagesWithEnvironmentName = results
-                  .filter((result) => result.status === "fulfilled")
-                  .flatMap(
-                     (result) =>
-                        (
-                           result as PromiseFulfilledResult<
-                              PackageWithEnvironment[]
-                           >
-                        ).value,
-                  );
-
-               logger.info(
-                  `[MCP LOG] Total packages found across all environments: ${allPackagesWithEnvironmentName.length}`,
-               );
-
-               const packageMetadata = RESOURCE_METADATA.package;
-               const mappedResources = allPackagesWithEnvironmentName.map(
-                  (pkg) => {
-                     const name = pkg.name || "unknown";
-                     // Construct URI using the package's specific environmentName
-                     const uri = `malloy://environment/${pkg.environmentName}/package/${name}`;
-                     return {
-                        uri: uri,
-                        name: name,
-                        type: "package",
-                        description: packageMetadata?.description as
-                           | string
-                           | undefined,
-                        metadata: packageMetadata,
-                     };
-                  },
-               );
-
-               logger.info(
-                  `[MCP LOG] ListResources (environment): Returning ${mappedResources.length} package resources.`,
-               );
-               return {
-                  resources: mappedResources,
-               };
-            } catch (error) {
-               // Catch errors from environmentStore.listEnvironments() itself
-               logger.error(`[MCP Server Error] Error listing environments:`, {
-                  error,
-               });
-               const errorDetails = getInternalError(
-                  `ListResources (environment - initial list)`,
-                  error,
-               );
-               logger.error("MCP ListResources (environment) error:", {
-                  error: errorDetails.message,
-               });
-               logger.info(
-                  "[MCP LOG] ListResources (environment): Returning empty on error listing environments.",
-               );
-               return { resources: [] };
-            }
-         },
-      }),
-      /** Handles GetResource requests for Malloy environments */
-      (uri, params) =>
-         handleResourceGet(
-            uri,
-            params,
-            "environment",
-            async ({ environmentName }: { environmentName?: unknown }) => {
-               logger.info(
-                  `[MCP LOG] Entering GetResource (environment) handler for environmentName: ${environmentName}`,
-               );
-               // Validate environment name parameter
-               if (typeof environmentName !== "string") {
-                  logger.error(
-                     "[MCP LOG] GetResource (environment): Invalid environment name param.",
-                  );
-                  throw new Error("Invalid environment name parameter.");
-               }
-
-               try {
-                  logger.info(
-                     `[MCP LOG] GetResource: Getting environment '${environmentName}'...`,
-                  );
-                  // Get the environment instance, but we might not need its metadata directly
-                  await environmentStore.getEnvironment(environmentName, false);
-                  // Construct the definition object expected by the test
-                  const definition = { name: environmentName };
-                  logger.info(
-                     `[MCP LOG] GetResource (environment): Returning definition for '${environmentName}'.`,
-                  );
-                  // Return the explicit definition structure
-                  return definition;
-               } catch (error) {
-                  logger.error(
-                     `[MCP LOG] GetResource (environment): Error caught for '${environmentName}':`,
-                     { error },
-                  );
-                  // Catch expected errors from this specific resource logic
-                  if (error instanceof Error) {
-                     // Use getNotFoundError for the specific environment not found case
-                     // or a generic message for the invalid param case.
-                     const errorDetails = getNotFoundError(
-                        error.message.includes("not found")
-                           ? `Environment '${environmentName}'` // More specific context
-                           : `Invalid environment identifier provided for URI ${uri.href}`, // Generic but informative
-                     );
-                     // Re-throw structured error for handleResourceGet to catch
-                     throw new McpGetResourceError(errorDetails);
-                  }
-                  // Re-throw unexpected errors to be caught by handleResourceGet's generic handler
-                  throw error;
-               }
-            },
-            RESOURCE_METADATA.environment,
-         ),
-   );
-}

package/src/mcp/resources/model_resource.ts

@@ -1,155 +0,0 @@
-import {
-   McpServer,
-   ResourceTemplate,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import { EnvironmentStore } from "../../service/environment_store";
-import {
-   ModelNotFoundError,
-   PackageNotFoundError,
-   ModelCompilationError,
-} from "../../errors";
-import { handleResourceGet, McpGetResourceError } from "../handler_utils";
-import { RESOURCE_METADATA } from "../resource_metadata";
-import {
-   getNotFoundError,
-   getMalloyErrorDetails,
-   getInternalError,
-} from "../error_messages";
-import type { components } from "../../api"; // Import the components type
-
-/**
- * Registers the Malloy Model resource type with the MCP server.
- * Handles getting details for a specific model.
- */
-export function registerModelResource(
-   mcpServer: McpServer,
-   environmentStore: EnvironmentStore,
-): void {
-   mcpServer.resource(
-      "model",
-      new ResourceTemplate(
-         "malloy://environment/{environmentName}/package/{packageName}/models/{modelPath}",
-         { list: undefined }, // No list handler for individual models
-      ),
-      /** Handles GetResource requests for specific Malloy Models */
-      (uri, params) =>
-         handleResourceGet(
-            uri,
-            params,
-            "model",
-            async ({
-               environmentName,
-               packageName,
-               modelPath,
-            }: {
-               environmentName?: unknown;
-               packageName?: unknown;
-               modelPath?: unknown;
-            }) => {
-               try {
-                  // Validate all parameters
-                  if (typeof environmentName !== "string") {
-                     throw new Error("Invalid environment name parameter.");
-                  }
-                  if (typeof packageName !== "string") {
-                     throw new Error("Invalid package name parameter.");
-                  }
-                  if (typeof modelPath !== "string") {
-                     throw new Error("Invalid model path parameter.");
-                  }
-
-                  // *** UPDATED LOGIC using EnvironmentStore ***
-                  // getEnvironment can throw EnvironmentNotFoundError (though unlikely if name is 'home')
-                  const environment = await environmentStore.getEnvironment(
-                     environmentName,
-                     false,
-                  );
-                  // getPackage can throw PackageNotFoundError
-                  const pkg = await environment.getPackage(packageName, false);
-                  // getModel is SYNCHRONOUS
-                  const modelInstance = pkg.getModel(modelPath);
-                  // *** END UPDATED LOGIC ***
-
-                  if (
-                     !modelInstance ||
-                     modelInstance.getModelType() === "notebook"
-                  ) {
-                     // Explicitly throw the expected error if not found or wrong type
-                     throw new ModelNotFoundError(modelPath);
-                  }
-
-                  // modelInstance.getModel() is ASYNC and can throw ModelCompilationError
-                  const compiledModelDefinition: components["schemas"]["CompiledModel"] =
-                     await modelInstance.getModel();
-
-                  // 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
-                  // Use validated string parameters here
-                  const safeEnvironmentName =
-                     typeof environmentName === "string"
-                        ? environmentName
-                        : "unknown";
-                  const safePackageName =
-                     typeof packageName === "string" ? packageName : "unknown";
-                  const safeModelPath =
-                     typeof modelPath === "string" ? modelPath : "unknown";
-
-                  const notFoundContext = `Model '${safeModelPath}' in package '${safePackageName}' for environment '${safeEnvironmentName}'`;
-                  const malloyErrorContext = `${safeEnvironmentName}/${safePackageName}/${safeModelPath}`;
-
-                  if (error instanceof PackageNotFoundError) {
-                     // Package not found during getPackage call
-                     errorDetails = getNotFoundError(
-                        `Package '${safePackageName}' in environment '${safeEnvironmentName}'`,
-                     );
-                  } else if (error instanceof ModelNotFoundError) {
-                     // Model not found (either from getModel or type check)
-                     errorDetails = getNotFoundError(notFoundContext);
-                  } else if (error instanceof ModelCompilationError) {
-                     // Compilation error when fetching model definition
-                     errorDetails = getMalloyErrorDetails(
-                        "GetResource (model)",
-                        malloyErrorContext,
-                        error,
-                     );
-                  } else if (error instanceof Error) {
-                     // Catch invalid param errors or other generic errors
-                     // Provide a clearer message differentiating param errors
-                     if (error.message.includes("parameter")) {
-                        errorDetails = getNotFoundError(
-                           `Invalid identifier parameter provided for URI ${uri.href}: ${error.message}`,
-                        );
-                     } else {
-                        errorDetails = getInternalError(
-                           "GetResource (model) - Unexpected Error",
-                           error,
-                        );
-                     }
-                  } else {
-                     // Fallback for truly unexpected non-Error throws
-                     errorDetails = getInternalError(
-                        "GetResource (model)",
-                        error,
-                     );
-                  }
-                  // Wrap and re-throw for handleResourceGet
-                  throw new McpGetResourceError(errorDetails);
-               }
-            },
-            RESOURCE_METADATA.model,
-         ),
-   );
-}

package/src/mcp/resources/notebook_resource.ts

@@ -1,137 +0,0 @@
-import {
-   McpServer,
-   ResourceTemplate,
-} from "@modelcontextprotocol/sdk/server/mcp.js";
-import { URL } from "url";
-import type { components } from "../../api"; // Need this for CompiledModel type
-import {
-   ModelCompilationError,
-   ModelNotFoundError,
-   PackageNotFoundError,
-} from "../../errors";
-import { logger } from "../../logger";
-import { EnvironmentStore } from "../../service/environment_store";
-import {
-   getInternalError,
-   getMalloyErrorDetails,
-   getNotFoundError,
-} from "../error_messages";
-import { handleResourceGet, McpGetResourceError } from "../handler_utils";
-import { RESOURCE_METADATA } from "../resource_metadata";
-
-// Define the expected parameter types
-type NotebookParams = {
-   environmentName?: unknown;
-   packageName?: unknown;
-   notebookName?: unknown;
-};
-
-/**
- * Registers the Malloy Notebook resource type.
- * Handles getting details for a specific notebook.
- */
-export function registerNotebookResource(
-   mcpServer: McpServer,
-   environmentStore: EnvironmentStore,
-): void {
-   mcpServer.resource(
-      "notebook",
-      new ResourceTemplate(
-         "malloy://environment/{environmentName}/package/{packageName}/notebooks/{notebookName}",
-         { list: undefined }, // Listing notebooks is not supported via this template
-      ),
-      (uri, params) =>
-         handleResourceGet(
-            uri,
-            params as NotebookParams,
-            "notebook",
-            async (
-               { environmentName, packageName, notebookName }: NotebookParams,
-               uri: URL,
-            ) => {
-               if (
-                  typeof environmentName !== "string" ||
-                  typeof packageName !== "string" ||
-                  typeof notebookName !== "string"
-               ) {
-                  throw new Error("Invalid parameters for notebook resource.");
-               }
-
-               let modelInstance;
-               try {
-                  const environment = await environmentStore.getEnvironment(
-                     environmentName,
-                     false,
-                  );
-                  const pkg = await environment.getPackage(packageName, false);
-                  // Get the model instance using the notebookName as the path
-                  modelInstance = pkg.getModel(notebookName);
-
-                  // Check if it exists and is actually a notebook
-                  if (
-                     !modelInstance ||
-                     modelInstance.getModelType() !== "notebook"
-                  ) {
-                     const isNotebookError =
-                        modelInstance?.getModelType() !== "notebook";
-                     const errorDetails = getNotFoundError(
-                        `Notebook '${notebookName}' in package '${packageName}' environment '${environmentName}'${
-                           isNotebookError ? " (not a .malloynb file)" : ""
-                        }`,
-                     );
-                     throw new McpGetResourceError(errorDetails);
-                  }
-
-                  // Now try to get the actual notebook content
-                  const notebookContent: components["schemas"]["RawNotebook"] =
-                     await modelInstance.getNotebook();
-                  return notebookContent;
-               } catch (error) {
-                  if (error instanceof McpGetResourceError) {
-                     throw error; // Re-throw if already formatted by checks above
-                  }
-
-                  // Handle specific errors like PackageNotFoundError or ModelCompilationError
-                  if (error instanceof PackageNotFoundError) {
-                     throw new McpGetResourceError(
-                        getNotFoundError(
-                           `Package '${packageName}' in environment '${environmentName}'`,
-                        ),
-                     );
-                  }
-                  // Handle ModelCompilationError from modelInstance.getModel()
-                  if (error instanceof ModelCompilationError) {
-                     const malloyErrorContext = `${environmentName}/${packageName}/${notebookName}`;
-                     throw new McpGetResourceError(
-                        getMalloyErrorDetails(
-                           "GetResource (notebook compilation)",
-                           malloyErrorContext,
-                           error,
-                        ),
-                     );
-                  }
-                  // Handle ModelNotFoundError specifically from pkg.getModel()
-                  if (error instanceof ModelNotFoundError) {
-                     throw new McpGetResourceError(
-                        getNotFoundError(
-                           `Notebook '${notebookName}' not found in package '${packageName}' environment '${environmentName}'`,
-                        ),
-                     );
-                  }
-
-                  // Handle other unexpected errors
-                  logger.error(
-                     `[MCP Server Error] Error fetching notebook '${notebookName}' from ${uri.href}:`,
-                     { error },
-                  );
-                  const fallbackErrorDetails = getInternalError(
-                     `GetResource (notebook: ${uri.href})`,
-                     error,
-                  );
-                  throw new McpGetResourceError(fallbackErrorDetails);
-               }
-            },
-            RESOURCE_METADATA.notebook,
-         ),
-   );
-}