@aborruso/ckan-mcp-server 0.4.30 → 0.4.32

package/dist/index.js

@@ -96,7 +96,100 @@ function getPortalApiUrlForHostname(hostname) {
 }
 
 // src/utils/http.ts
+var loadZlib = /* @__PURE__ */ (() => {
+  let cached = null;
+  return async () => {
+    if (!cached) {
+      cached = (async () => {
+        try {
+          const mod = await import("node:zlib");
+          return mod;
+        } catch {
+          return null;
+        }
+      })();
+    }
+    return cached;
+  };
+})();
+function getHeaderValue(headers, name) {
+  if (!headers) {
+    return void 0;
+  }
+  const target = name.toLowerCase();
+  for (const [key, value] of Object.entries(headers)) {
+    if (key.toLowerCase() === target) {
+      return Array.isArray(value) ? value.join(",") : String(value);
+    }
+  }
+  return void 0;
+}
+function asBuffer(data) {
+  if (!data) {
+    return void 0;
+  }
+  if (typeof Buffer === "undefined") {
+    return void 0;
+  }
+  if (Buffer.isBuffer(data)) {
+    return data;
+  }
+  if (data instanceof ArrayBuffer) {
+    return Buffer.from(data);
+  }
+  if (ArrayBuffer.isView(data)) {
+    return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+  }
+  return void 0;
+}
+async function decodePossiblyCompressed(data, headers) {
+  if (data === null || data === void 0) {
+    return data;
+  }
+  if (typeof data === "object" && !asBuffer(data)) {
+    return data;
+  }
+  if (typeof data === "string") {
+    try {
+      return JSON.parse(data);
+    } catch {
+      return data;
+    }
+  }
+  const buffer = asBuffer(data);
+  if (!buffer) {
+    return data;
+  }
+  const encoding = getHeaderValue(headers, "content-encoding");
+  let decodedBuffer = buffer;
+  const zlib = await loadZlib();
+  try {
+    if (zlib) {
+      if (encoding?.includes("gzip")) {
+        decodedBuffer = zlib.gunzipSync(buffer);
+      } else if (encoding?.includes("br")) {
+        decodedBuffer = zlib.brotliDecompressSync(buffer);
+      } else if (encoding?.includes("deflate")) {
+        decodedBuffer = zlib.inflateSync(buffer);
+      } else if (buffer.length >= 2 && buffer[0] === 31 && buffer[1] === 139) {
+        decodedBuffer = zlib.gunzipSync(buffer);
+      }
+    }
+  } catch {
+    decodedBuffer = buffer;
+  }
+  const text = decodedBuffer.toString("utf-8").trim();
+  if (!text) {
+    return text;
+  }
+  try {
+    return JSON.parse(text);
+  } catch {
+    return text;
+  }
+}
 async function makeCkanRequest(serverUrl, action, params = {}) {
+  const isNode = typeof process !== "undefined" && !!process.versions?.node;
   let resolvedServerUrl = serverUrl;
   try {
     const hostname = new URL(serverUrl).hostname;
@@ -109,29 +202,64 @@ async function makeCkanRequest(serverUrl, action, params = {}) {
   const baseUrl = resolvedServerUrl.replace(/\/$/, "");
   const url = `${baseUrl}/api/3/action/${action}`;
   try {
-    const response = await axios.get(url, {
-      params,
-      timeout: 3e4,
-      headers: {
-        Accept: "application/json, text/plain, */*",
-        "Accept-Language": "en-US,en;q=0.9,it;q=0.8",
-        "Accept-Encoding": "gzip, deflate, br",
-        Connection: "keep-alive",
-        Referer: `${baseUrl}/`,
-        "Sec-Fetch-Site": "same-origin",
-        "Sec-Fetch-Mode": "navigate",
-        "Sec-Fetch-Dest": "document",
-        "Upgrade-Insecure-Requests": "1",
-        "Sec-CH-UA": '"Chromium";v="120", "Not?A_Brand";v="24", "Google Chrome";v="120"',
-        "Sec-CH-UA-Mobile": "?0",
-        "Sec-CH-UA-Platform": '"Linux"',
-        "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+    let decodedData;
+    if (isNode) {
+      const response = await axios.get(url, {
+        params,
+        timeout: 3e4,
+        responseType: "arraybuffer",
+        headers: {
+          Accept: "application/json, text/plain, */*",
+          "Accept-Language": "en-US,en;q=0.9,it;q=0.8",
+          "Accept-Encoding": "gzip, deflate, br",
+          Connection: "keep-alive",
+          Referer: `${baseUrl}/`,
+          "Sec-Fetch-Site": "same-origin",
+          "Sec-Fetch-Mode": "navigate",
+          "Sec-Fetch-Dest": "document",
+          "Upgrade-Insecure-Requests": "1",
+          "Sec-CH-UA": '"Chromium";v="120", "Not?A_Brand";v="24", "Google Chrome";v="120"',
+          "Sec-CH-UA-Mobile": "?0",
+          "Sec-CH-UA-Platform": '"Linux"',
+          "User-Agent": "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36"
+        }
+      });
+      decodedData = await decodePossiblyCompressed(
+        response.data,
+        response.headers
+      );
+    } else {
+      const searchParams = new URLSearchParams();
+      for (const [key, value] of Object.entries(params)) {
+        if (value === void 0 || value === null) {
+          continue;
+        }
+        searchParams.set(key, String(value));
       }
-    });
-    if (response.data && response.data.success === true) {
-      return response.data.result;
+      const fetchUrl = searchParams.toString() ? `${url}?${searchParams.toString()}` : url;
+      const response = await fetch(fetchUrl, {
+        method: "GET",
+        headers: {
+          Accept: "application/json, text/plain, */*",
+          "Accept-Language": "en-US,en;q=0.9,it;q=0.8"
+        }
+      });
+      if (!response.ok) {
+        throw new Error(`CKAN API error (${response.status}): ${response.statusText}`);
+      }
+      const buffer = await response.arrayBuffer();
+      const headers = {};
+      response.headers.forEach((headerValue, headerKey) => {
+        headers[headerKey] = headerValue;
+      });
+      decodedData = await decodePossiblyCompressed(buffer, headers);
+    }
+    if (decodedData && decodedData.success === true) {
+      return decodedData.result;
     } else {
-      throw new Error(`CKAN API returned success=false: ${JSON.stringify(response.data)}`);
+      throw new Error(
+        `CKAN API returned success=false: ${JSON.stringify(decodedData)}`
+      );
     }
   } catch (error) {
     if (axios.isAxiosError(error)) {
@@ -329,6 +457,194 @@ var scoreDatasetRelevance = (query, dataset, weights = DEFAULT_RELEVANCE_WEIGHTS
   breakdown.total = breakdown.title + breakdown.notes + breakdown.tags + breakdown.organization;
   return { total: breakdown.total, breakdown, terms };
 };
+var parseAccessServices = (resource) => {
+  if (!resource || resource.access_services == null) return [];
+  const raw = resource.access_services;
+  if (Array.isArray(raw)) return raw;
+  if (typeof raw === "string" && raw.trim().length > 0) {
+    try {
+      const parsed = JSON.parse(raw);
+      return Array.isArray(parsed) ? parsed : [];
+    } catch {
+      return [];
+    }
+  }
+  return [];
+};
+var extractServiceEndpoints = (services) => {
+  const endpoints = [];
+  for (const service of services) {
+    const urls = service.endpoint_url;
+    if (Array.isArray(urls)) {
+      for (const url of urls) {
+        if (typeof url === "string" && url.trim().length > 0) endpoints.push(url.trim());
+      }
+    } else if (typeof urls === "string" && urls.trim().length > 0) {
+      endpoints.push(urls.trim());
+    }
+  }
+  return Array.from(new Set(endpoints));
+};
+var resolveDownloadUrl = (resource) => {
+  if (!resource) return null;
+  const downloadUrl = typeof resource.download_url === "string" ? resource.download_url.trim() : "";
+  const accessUrl = typeof resource.access_url === "string" ? resource.access_url.trim() : "";
+  const url = typeof resource.url === "string" ? resource.url.trim() : "";
+  return downloadUrl || accessUrl || url || null;
+};
+var enrichPackageShowResult = (result) => ({
+  ...result,
+  metadata_harvested_at: result.metadata_modified ?? null,
+  resources: Array.isArray(result.resources) ? result.resources.map((resource) => {
+    const accessServices = parseAccessServices(resource);
+    const accessEndpoints = extractServiceEndpoints(accessServices);
+    const effectiveDownloadUrl = resolveDownloadUrl(resource);
+    if (accessEndpoints.length === 0 && !effectiveDownloadUrl) return resource;
+    return {
+      ...resource,
+      ...accessEndpoints.length > 0 ? { access_service_endpoints: accessEndpoints } : {},
+      ...effectiveDownloadUrl ? { effective_download_url: effectiveDownloadUrl } : {}
+    };
+  }) : result.resources
+});
+var formatPackageShowMarkdown = (result, serverUrl) => {
+  let markdown = `# Dataset: ${result.title || result.name}
+
+`;
+  markdown += `**Server**: ${serverUrl}
+`;
+  markdown += `**Link**: ${getDatasetViewUrl(serverUrl, result)}
+
+`;
+  markdown += `## Basic Information
+
+`;
+  markdown += `- **ID**: \`${result.id}\`
+`;
+  markdown += `- **Name**: \`${result.name}\`
+`;
+  if (result.author) markdown += `- **Author**: ${result.author}
+`;
+  if (result.author_email) markdown += `- **Author Email**: ${result.author_email}
+`;
+  if (result.maintainer) markdown += `- **Maintainer**: ${result.maintainer}
+`;
+  if (result.maintainer_email) markdown += `- **Maintainer Email**: ${result.maintainer_email}
+`;
+  markdown += `- **License**: ${result.license_title || result.license_id || "Not specified"}
+`;
+  markdown += `- **State**: ${result.state}
+`;
+  markdown += `- **Created**: ${formatDate(result.metadata_created)}
+`;
+  if (result.issued) {
+    markdown += `- **Issued**: ${formatDate(result.issued)}
+`;
+  } else {
+    markdown += `- **Issued**: (missing in CKAN; downstream RDF may default to metadata_created, which is a record timestamp)
+`;
+  }
+  if (result.modified) markdown += `- **Modified (Content)**: ${formatDate(result.modified)}
+`;
+  markdown += `- **Metadata Modified (Record)**: ${formatDate(result.metadata_modified)}
+
+`;
+  if (result.organization) {
+    markdown += `## Organization
+
+`;
+    markdown += `- **Name**: ${result.organization.title || result.organization.name}
+`;
+    markdown += `- **ID**: \`${result.organization.id}\`
+
+`;
+  }
+  if (result.notes) {
+    markdown += `## Description
+
+${result.notes}
+
+`;
+  }
+  if (result.tags && result.tags.length > 0) {
+    markdown += `## Tags
+
+`;
+    markdown += result.tags.map((t) => `- ${t.name}`).join("\n") + "\n\n";
+  }
+  if (result.groups && result.groups.length > 0) {
+    markdown += `## Groups
+
+`;
+    for (const group of result.groups) {
+      markdown += `- **${group.title || group.name}** (\`${group.name}\`)
+`;
+    }
+    markdown += "\n";
+  }
+  if (result.resources && result.resources.length > 0) {
+    markdown += `## Resources (${result.resources.length})
+
+`;
+    for (const resource of result.resources) {
+      markdown += `### ${resource.name || "Unnamed Resource"}
+
+`;
+      markdown += `- **ID**: \`${resource.id}\`
+`;
+      markdown += `- **Format**: ${resource.format || "Unknown"}
+`;
+      if (resource.description) markdown += `- **Description**: ${resource.description}
+`;
+      markdown += `- **URL**: ${resource.url}
+`;
+      const accessServices = parseAccessServices(resource);
+      const accessEndpoints = extractServiceEndpoints(accessServices);
+      if (accessEndpoints.length > 0) {
+        markdown += `- **Access Service Endpoints**: ${accessEndpoints.join(", ")}
+`;
+      }
+      const effectiveDownloadUrl = resolveDownloadUrl(resource);
+      if (effectiveDownloadUrl) {
+        markdown += `- **Effective Download URL**: ${effectiveDownloadUrl}
+`;
+      }
+      if (resource.size) {
+        const formatBytes = (bytes) => {
+          if (!bytes || bytes === 0) return "0 B";
+          const k = 1024;
+          const sizes = ["B", "KB", "MB", "GB"];
+          const i = Math.floor(Math.log(bytes) / Math.log(k));
+          return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
+        };
+        markdown += `- **Size**: ${formatBytes(resource.size)}
+`;
+      }
+      if (resource.mimetype) markdown += `- **MIME Type**: ${resource.mimetype}
+`;
+      markdown += `- **Created**: ${formatDate(resource.created)}
+`;
+      if (resource.last_modified) markdown += `- **Modified**: ${formatDate(resource.last_modified)}
+`;
+      if (resource.datastore_active !== void 0) {
+        markdown += `- **DataStore**: ${resource.datastore_active ? "\u2705 Available" : "\u274C Not available"}
+`;
+      }
+      markdown += "\n";
+    }
+  }
+  if (result.extras && result.extras.length > 0) {
+    markdown += `## Extra Fields
+
+`;
+    for (const extra of result.extras) {
+      markdown += `- **${extra.key}**: ${extra.value}
+`;
+    }
+    markdown += "\n";
+  }
+  return markdown;
+};
 function registerPackageTools(server2) {
   server2.registerTool(
     "ckan_package_search",
@@ -344,6 +660,19 @@ Some CKAN portals use a restrictive default query parser that can break long OR
 For those portals, this tool may force the query into 'text:(...)' based on per-portal config.
 You can override with 'query_parser' to force or disable this behavior per request.
 
+Important - Date field semantics:
+  - issued: publisher's content publish date when available (best proxy for "created/published")
+  - modified: publisher's content update date when available
+  - metadata_created: CKAN record creation timestamp (publish time on source portals,
+    harvest time on aggregators; fallback for "created" if issued missing)
+  - metadata_modified: CKAN record update timestamp (publish time on source portals,
+    harvest time on aggregators; use for "updated/modified in last X")
+
+Content-recent helper:
+  - content_recent: if true, rewrites the query to use issued with a fallback to
+    metadata_created when issued is missing.
+  - content_recent_days: window for content_recent (default 30 days).
+
 Args:
   - server_url (string): Base URL of CKAN server (e.g., "https://dati.gov.it/opendata")
   - q (string): Search query using Solr syntax (default: "*:*" for all)
@@ -428,6 +757,8 @@ Examples:
         facet_field: z2.array(z2.string()).optional().describe("Fields to facet on"),
         facet_limit: z2.number().int().min(1).optional().default(50).describe("Maximum facet values per field"),
         include_drafts: z2.boolean().optional().default(false).describe("Include draft datasets"),
+        content_recent: z2.boolean().optional().default(false).describe("Use issued date with fallback to metadata_created for recent content"),
+        content_recent_days: z2.number().int().min(1).optional().default(30).describe("Day window for content_recent (default 30)"),
         query_parser: z2.enum(["default", "text"]).optional().describe("Override search parser ('text' forces text:(...) on non-fielded queries)"),
         response_format: ResponseFormatSchema
       }).strict(),
@@ -440,9 +771,18 @@ Examples:
     },
     async (params) => {
       try {
+        const userQuery = params.q;
+        let query = userQuery;
+        let effectiveSort = params.sort;
+        if (params.content_recent) {
+          const days = params.content_recent_days ?? 30;
+          const recentClause = `(issued:[NOW-${days}DAYS TO NOW]) OR (-issued:* AND metadata_created:[NOW-${days}DAYS TO NOW])`;
+          query = userQuery && userQuery !== "*:*" ? `(${userQuery}) AND (${recentClause})` : recentClause;
+          if (!effectiveSort) effectiveSort = "issued desc, metadata_created desc";
+        }
         const { effectiveQuery } = resolveSearchQuery(
           params.server_url,
-          params.q,
+          query,
           params.query_parser
         );
         const apiParams = {
@@ -452,7 +792,7 @@ Examples:
           include_private: params.include_drafts
         };
         if (params.fq) apiParams.fq = params.fq;
-        if (params.sort) apiParams.sort = params.sort;
+        if (effectiveSort) apiParams.sort = effectiveSort;
         if (params.facet_field && params.facet_field.length > 0) {
           apiParams["facet.field"] = JSON.stringify(params.facet_field);
           apiParams["facet.limit"] = params.facet_limit;
@@ -471,8 +811,10 @@ Examples:
         let markdown = `# CKAN Package Search Results
 
 **Server**: ${params.server_url}
-**Query**: ${params.q}
-${effectiveQuery !== params.q ? `**Effective Query**: ${effectiveQuery}
+**Query**: ${userQuery}
+${params.content_recent ? `**Content Recent**: last ${params.content_recent_days ?? 30} days (issued with metadata_created fallback)
+` : ""}
+${effectiveQuery !== userQuery ? `**Effective Query**: ${effectiveQuery}
 ` : ""}
 ${params.fq ? `**Filter**: ${params.fq}
 ` : ""}
@@ -751,6 +1093,12 @@ Examples:
 
 Returns full details including resources, organization, tags, and all metadata fields.
 
+Notes:
+  - metadata_modified is a CKAN record timestamp (publish time on source portals,
+    harvest time on aggregators), not the content date.
+  - issued/modified are content dates when provided by the publisher.
+  - JSON output adds metadata_harvested_at (same as metadata_modified).
+
 Args:
   - server_url (string): Base URL of CKAN server
   - id (string): Dataset ID or name (machine-readable slug)
@@ -787,126 +1135,13 @@ Examples:
           }
         );
         if (params.response_format === "json" /* JSON */) {
+          const enriched = enrichPackageShowResult(result);
           return {
-            content: [{ type: "text", text: truncateText(JSON.stringify(result, null, 2)) }],
-            structuredContent: result
+            content: [{ type: "text", text: truncateText(JSON.stringify(enriched, null, 2)) }],
+            structuredContent: enriched
           };
         }
-        let markdown = `# Dataset: ${result.title || result.name}
-
-`;
-        markdown += `**Server**: ${params.server_url}
-`;
-        markdown += `**Link**: ${getDatasetViewUrl(params.server_url, result)}
-
-`;
-        markdown += `## Basic Information
-
-`;
-        markdown += `- **ID**: \`${result.id}\`
-`;
-        markdown += `- **Name**: \`${result.name}\`
-`;
-        if (result.author) markdown += `- **Author**: ${result.author}
-`;
-        if (result.author_email) markdown += `- **Author Email**: ${result.author_email}
-`;
-        if (result.maintainer) markdown += `- **Maintainer**: ${result.maintainer}
-`;
-        if (result.maintainer_email) markdown += `- **Maintainer Email**: ${result.maintainer_email}
-`;
-        markdown += `- **License**: ${result.license_title || result.license_id || "Not specified"}
-`;
-        markdown += `- **State**: ${result.state}
-`;
-        markdown += `- **Created**: ${formatDate(result.metadata_created)}
-`;
-        markdown += `- **Modified**: ${formatDate(result.metadata_modified)}
-
-`;
-        if (result.organization) {
-          markdown += `## Organization
-
-`;
-          markdown += `- **Name**: ${result.organization.title || result.organization.name}
-`;
-          markdown += `- **ID**: \`${result.organization.id}\`
-
-`;
-        }
-        if (result.notes) {
-          markdown += `## Description
-
-${result.notes}
-
-`;
-        }
-        if (result.tags && result.tags.length > 0) {
-          markdown += `## Tags
-
-`;
-          markdown += result.tags.map((t) => `- ${t.name}`).join("\n") + "\n\n";
-        }
-        if (result.groups && result.groups.length > 0) {
-          markdown += `## Groups
-
-`;
-          for (const group of result.groups) {
-            markdown += `- **${group.title || group.name}** (\`${group.name}\`)
-`;
-          }
-          markdown += "\n";
-        }
-        if (result.resources && result.resources.length > 0) {
-          markdown += `## Resources (${result.resources.length})
-
-`;
-          for (const resource of result.resources) {
-            markdown += `### ${resource.name || "Unnamed Resource"}
-
-`;
-            markdown += `- **ID**: \`${resource.id}\`
-`;
-            markdown += `- **Format**: ${resource.format || "Unknown"}
-`;
-            if (resource.description) markdown += `- **Description**: ${resource.description}
-`;
-            markdown += `- **URL**: ${resource.url}
-`;
-            if (resource.size) {
-              const formatBytes = (bytes) => {
-                if (!bytes || bytes === 0) return "0 B";
-                const k = 1024;
-                const sizes = ["B", "KB", "MB", "GB"];
-                const i = Math.floor(Math.log(bytes) / Math.log(k));
-                return parseFloat((bytes / Math.pow(k, i)).toFixed(2)) + " " + sizes[i];
-              };
-              markdown += `- **Size**: ${formatBytes(resource.size)}
-`;
-            }
-            if (resource.mimetype) markdown += `- **MIME Type**: ${resource.mimetype}
-`;
-            markdown += `- **Created**: ${formatDate(resource.created)}
-`;
-            if (resource.last_modified) markdown += `- **Modified**: ${formatDate(resource.last_modified)}
-`;
-            if (resource.datastore_active !== void 0) {
-              markdown += `- **DataStore**: ${resource.datastore_active ? "\u2705 Available" : "\u274C Not available"}
-`;
-            }
-            markdown += "\n";
-          }
-        }
-        if (result.extras && result.extras.length > 0) {
-          markdown += `## Extra Fields
-
-`;
-          for (const extra of result.extras) {
-            markdown += `- **${extra.key}**: ${extra.value}
-`;
-          }
-          markdown += "\n";
-        }
+        const markdown = formatPackageShowMarkdown(result, params.server_url);
         return {
           content: [{ type: "text", text: truncateText(markdown) }]
         };
@@ -2890,7 +3125,11 @@ ckan_package_search({
   q: "tags:${theme}",
   sort: "metadata_modified desc",
   rows: ${rows}
-})`;
+})
+
+Note: metadata_modified is a CKAN record timestamp (publish time on source portals,
+harvest time on aggregators). If the user asks for
+content publication dates, prefer issued (or modified) with explicit ISO ranges.`;
 var registerThemePrompt = (server2) => {
   server2.registerPrompt(
     THEME_PROMPT_NAME,
@@ -2931,7 +3170,11 @@ ckan_package_search({
   fq: "organization:<org-id>",
   sort: "metadata_modified desc",
   rows: ${rows}
-})`;
+})
+
+Note: metadata_modified is a CKAN record timestamp (publish time on source portals,
+harvest time on aggregators). If the user asks for
+content publication dates, prefer issued (or modified) with explicit ISO ranges.`;
 var registerOrganizationPrompt = (server2) => {
   server2.registerPrompt(
     ORGANIZATION_PROMPT_NAME,
@@ -2962,7 +3205,10 @@ ckan_package_search({
   rows: ${rows}
 })
 
-Tip: try uppercase (CSV/JSON) or common variants if results are sparse.`;
+Tip: try uppercase (CSV/JSON) or common variants if results are sparse.
+Note: metadata_modified is a CKAN record timestamp (publish time on source portals,
+harvest time on aggregators). If the user asks for
+content publication dates, prefer issued (or modified) with explicit ISO ranges.`;
 var registerFormatPrompt = (server2) => {
   server2.registerPrompt(
     FORMAT_PROMPT_NAME,
@@ -2984,7 +3230,8 @@ import { z as z12 } from "zod";
 var RECENT_PROMPT_NAME = "ckan-recent-datasets";
 var buildRecentPromptText = (serverUrl, rows) => `# Guided search: recent datasets
 
-Use \`ckan_package_search\` sorted by modification date:
+Use \`ckan_package_search\` sorted by metadata modification date (CKAN record updates,
+publish time on source portals, harvest time on aggregators):
 
 ckan_package_search({
   server_url: "${serverUrl}",
@@ -2993,13 +3240,32 @@ ckan_package_search({
   rows: ${rows}
 })
 
-Optional: add a date filter for the last N days:
+Optional: add a date filter for the last N days (record metadata):
 
 ckan_package_search({
   server_url: "${serverUrl}",
   q: "metadata_modified:[NOW-30DAYS TO *]",
   sort: "metadata_modified desc",
   rows: ${rows}
+})
+
+If the user asks for recent content publication dates, prefer \`issued\` (or \`modified\`)
+from the publisher and use explicit ISO date ranges:
+
+ckan_package_search({
+  server_url: "${serverUrl}",
+  q: "issued:[2025-01-01T00:00:00Z TO *]",
+  sort: "issued desc",
+  rows: ${rows}
+})
+
+Or use the helper flag to apply issued with a metadata_created fallback:
+
+ckan_package_search({
+  server_url: "${serverUrl}",
+  content_recent: true,
+  content_recent_days: 30,
+  rows: ${rows}
 })`;
 var registerRecentPrompt = (server2) => {
   server2.registerPrompt(
@@ -3080,7 +3346,7 @@ var registerAllPrompts = (server2) => {
 function createServer() {
   return new McpServer({
     name: "ckan-mcp-server",
-    version: "0.4.26"
+    version: "0.4.27"
   });
 }
 function registerAll(server2) {