@wisewandtools/mcp-server 2.2.1 → 2.2.4

package/dist/index.js

@@ -1203,6 +1203,27 @@ function validateUuid(value) {
   return str;
 }
 __name(validateUuid, "validateUuid");
+function resolveArray(args, key) {
+  let value = args[key];
+  if (value === void 0 || value === null) {
+    throw new ToolInputError(`Missing required parameter: ${key}`);
+  }
+  if (typeof value === "string") {
+    try {
+      value = JSON.parse(value);
+    } catch {
+      throw new ToolInputError(`Invalid ${key} format: expected JSON array`);
+    }
+  }
+  if (!Array.isArray(value)) {
+    throw new ToolInputError(`Invalid ${key} format: expected array, got ${typeof value}`);
+  }
+  if (value.length === 0) {
+    throw new ToolInputError(`${key} must not be empty`);
+  }
+  return value;
+}
+__name(resolveArray, "resolveArray");
 
 // src/handlers/tools/ArticleToolHandler.ts
 var boolField = z2.union([z2.boolean(), z2.string()]).transform(
@@ -1501,7 +1522,7 @@ var ArticleToolHandler = class {
       publishwordpress_date: { type: "string", description: "WordPress publish date (ISO 8601)" },
       publishwordpress_status: { type: "string", enum: ["draft", "publish", "future"], description: "WordPress post status", default: "draft" },
       publishwordpress_category: { type: "number", description: "WordPress category ID" },
-      publishwordpress_author: { type: "number", description: "WordPress author ID" },
+      publishwordpress_author: { type: "number", description: "WordPress author ID. CAUTION: If the WP connection user lacks edit_others_posts capability, setting this will cause publishing to fail with rest_cannot_edit_others. Omit unless the WP user has admin/editor role." },
       publishwordpress_connection: { type: "string", format: "uuid", description: "WordPress connection ID" },
       // Shopify Publishing
       use_publishshopify: { type: "boolean", description: "Automatically publish to Shopify" },
@@ -1573,21 +1594,38 @@ var ArticleToolHandler = class {
           const validated = CreateArticleSchema.parse(args);
           const apiInput = this.buildApiInput(validated);
           const article = await this.apiClient.createArticle(apiInput);
-          await this.cache.set(`article:${article.id}`, article, 300);
           this.metrics.recordAPICall("create_article", "success");
+          const warnings = [];
+          if (validated.use_publishwordpress && !validated.publishwordpress_connection) {
+            warnings.push("Warning: use_publishwordpress is true but publishwordpress_connection is not set. The article may not be published to WordPress. Provide a publishwordpress_connection UUID.");
+          }
+          if (validated.publishwordpress_author) {
+            warnings.push(
+              'Warning: publishwordpress_author is set. If the WP connection user lacks edit_others_posts capability, auto-publish will silently fail with "rest_cannot_edit_others". Omit publishwordpress_author unless the WP user has admin/editor role.'
+            );
+          }
+          const hasAutoPublish = validated.use_publishwordpress || validated.use_publishshopify || validated.use_publishprestashop || validated.use_publishwoocommerce;
+          const next_steps = hasAutoPublish ? [
+            `Generation auto-triggered. Use 'get_article' with id: ${article.id} to check progress`,
+            `Use 'get_article_output' with id: ${article.id} to get content once ready`
+          ] : [
+            `Use 'generate_article' with id: ${article.id} to start content generation`,
+            `Use 'get_article' with id: ${article.id} to check status`
+          ];
+          const response = {
+            success: true,
+            article_id: article.id,
+            title: article.title || "Article created",
+            message: `Article "${article.title || validated.subject}" created successfully.`,
+            next_steps
+          };
+          if (warnings.length > 0) {
+            response.warnings = warnings;
+          }
           return {
             content: [{
               type: "text",
-              text: JSON.stringify({
-                success: true,
-                article_id: article.id,
-                title: article.title || "Article created",
-                message: `Article "${article.title || validated.subject}" created successfully.`,
-                next_steps: [
-                  `Use 'generate_article' with id: ${article.id} to start content generation`,
-                  `Use 'get_article' with id: ${article.id} to check status`
-                ]
-              }, null, 2)
+              text: JSON.stringify(response, null, 2)
             }]
           };
         } catch (error) {
@@ -1655,6 +1693,22 @@ var ArticleToolHandler = class {
           }
           throw new Error(`Generation timeout after ${max_wait_time} seconds`);
         } catch (error) {
+          const errorMsg = (error.message || "").toLowerCase();
+          if (errorMsg.includes("already running") || errorMsg.includes("in queue") || errorMsg.includes("already in progress")) {
+            const article_id = args.id || args.article_id;
+            return {
+              content: [{
+                type: "text",
+                text: JSON.stringify({
+                  success: true,
+                  article_id,
+                  status: "already_running",
+                  message: "Article generation is already in progress. Use get_article to check status.",
+                  next_steps: [`Use 'get_article' with id: ${article_id} to check progress`]
+                }, null, 2)
+              }]
+            };
+          }
           logger.error("Failed to generate article", { error: error.message });
           this.metrics.recordAPICall("generate_article", "error");
           return { content: [{ type: "text", text: JSON.stringify({ error: true, message: error.message || "Failed to generate article" }, null, 2) }], isError: true };
@@ -1807,19 +1861,30 @@ var ArticleToolHandler = class {
             await this.cache.set(cacheKey, output, 600);
           }
           this.metrics.recordAPICall("get_article_output", "success");
+          const rawOutput = output;
+          const normalizedOutput = rawOutput?.data?.output ?? rawOutput?.data ?? rawOutput?.output ?? rawOutput;
+          logger.debug("get_article_output raw response keys", { keys: Object.keys(rawOutput || {}), normalizedKeys: Object.keys(normalizedOutput || {}) });
           let formattedOutput;
           switch (format) {
-            case "html":
-              formattedOutput = { html: output.html_content, title: output.title };
+            case "html": {
+              const html = normalizedOutput?.html_content ?? normalizedOutput?.content ?? null;
+              const title = normalizedOutput?.title ?? null;
+              formattedOutput = html || title ? { html, title } : { ...normalizedOutput, _note: "Fields not found at expected paths (html_content, title)" };
               break;
+            }
             case "markdown":
-              formattedOutput = { content: output.content, title: output.title };
+              formattedOutput = { content: normalizedOutput?.content ?? normalizedOutput?.markdown ?? null, title: normalizedOutput?.title ?? null };
               break;
-            case "summary":
-              formattedOutput = { title: output.title, excerpt: output.excerpt, word_count: output.word_count, seo_score: output.seo_score };
+            case "summary": {
+              const title = normalizedOutput?.title ?? null;
+              const excerpt = normalizedOutput?.excerpt ?? null;
+              const word_count = normalizedOutput?.word_count ?? null;
+              const seo_score = normalizedOutput?.seo_score ?? null;
+              formattedOutput = title || excerpt ? { title, excerpt, word_count, seo_score } : { ...normalizedOutput, _note: "Fields not found at expected paths (title, excerpt)" };
               break;
+            }
             default:
-              formattedOutput = output;
+              formattedOutput = normalizedOutput;
           }
           return { content: [{ type: "text", text: JSON.stringify({ success: true, article_id, format, output: formattedOutput, from_cache: !!cached }, null, 2) }] };
         } catch (error) {
@@ -2280,33 +2345,115 @@ var PublishingToolHandler = class {
   publishToWordPressTool() {
     return {
       name: "publish_to_wordpress",
-      description: "Publish content to WordPress",
+      description: "Publish content to WordPress. connection_id must reference a WordPress connection with sufficient permissions.",
       inputSchema: {
         type: "object",
         properties: {
           entity_id: { type: "string", format: "uuid", description: "ID of the article/content to publish" },
           status: { type: "string", enum: ["draft", "publish", "future"], description: "Publishing status", default: "draft" },
-          schedule_date: { type: "string", format: "date-time", description: "Schedule date for future publishing (ISO 8601)" },
+          date: { type: "string", format: "date-time", description: 'Publication date (ISO 8601). Required when status is "future".' },
           category_id: { type: "number", description: "WordPress category ID" },
-          author_id: { type: "number", description: "WordPress author ID" },
-          connection_id: { type: "string", format: "uuid", description: "WordPress connection ID" }
+          author_id: { type: "number", description: "WordPress author ID. CAUTION: If the WP connection user lacks edit_others_posts capability, setting this will cause publishing to fail with rest_cannot_edit_others. Omit unless the WP user has admin/editor role." },
+          connection_id: { type: "string", format: "uuid", description: "WordPress connection ID (must have sufficient WP permissions)" },
+          clear_author: { type: "boolean", description: 'Clear the stored publishwordpress_author from article config before publishing. Use this to prevent "rest_cannot_edit_others" errors.', default: false }
         },
-        required: ["entity_id"]
+        required: ["entity_id", "connection_id"]
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { entity_id, ...options } = args;
+          const entity_id = resolveId(args, "entity_id");
+          const { connection_id, status, date, category_id, author_id } = args;
+          const clear_author = args.clear_author ?? false;
+          const warnings = [];
+          try {
+            const article = await this.apiClient.getArticle(entity_id);
+            const articleStatus = article.status || "unknown";
+            if (articleStatus !== "completed" && articleStatus !== "success") {
+              const statusMessages = {
+                draft: "Article has not been generated yet.",
+                pending: "Article generation is still pending.",
+                processing: "Article is currently being generated.",
+                failed: "Article generation failed previously.",
+                error: "Article encountered an error during generation."
+              };
+              return {
+                content: [{
+                  type: "text",
+                  text: JSON.stringify({
+                    error: true,
+                    message: statusMessages[articleStatus] || `Article status is "${articleStatus}" \u2014 content must be generated before publishing.`,
+                    article_status: articleStatus,
+                    entity_id,
+                    next_steps: [
+                      `Use 'generate_article' with id: ${entity_id} to generate content first`,
+                      `Use 'get_article' with id: ${entity_id} to check current status`
+                    ]
+                  }, null, 2)
+                }],
+                isError: true
+              };
+            }
+            const storedAuthor = article.data?.input?.publishwordpress_author;
+            if (storedAuthor && !author_id) {
+              if (clear_author) {
+                try {
+                  await this.apiClient.updateArticle(entity_id, { publishwordpress_author: null });
+                  try {
+                    const updated = await this.apiClient.getArticle(entity_id);
+                    const stillPresent = updated.data?.input?.publishwordpress_author;
+                    if (stillPresent) {
+                      logger.warn("publishwordpress_author still present after clear attempt", { entity_id, value: stillPresent });
+                      warnings.push(`publishwordpress_author may not have been fully cleared (still shows "${stillPresent}"). Publishing may still fail.`);
+                    } else {
+                      logger.info("Cleared stored publishwordpress_author before publishing", { entity_id, cleared_author: storedAuthor });
+                    }
+                  } catch (verifyError) {
+                    logger.warn("Could not verify publishwordpress_author was cleared", { error: verifyError.message });
+                  }
+                } catch (clearError) {
+                  logger.warn("Failed to clear publishwordpress_author", { error: clearError.message });
+                  warnings.push(`Could not clear stored publishwordpress_author (${storedAuthor}). Publishing may fail if the WP connection user lacks edit_others_posts.`);
+                }
+              } else {
+                warnings.push(
+                  `Article has stored publishwordpress_author=${storedAuthor}. If the WP connection user lacks edit_others_posts capability, publishing will fail with "rest_cannot_edit_others". Use clear_author: true to clear it before publishing.`
+                );
+              }
+            }
+          } catch (fetchError) {
+            logger.warn("Could not pre-validate article before publishing", { entity_id, error: fetchError.message });
+          }
+          const options = { connection_id };
+          if (status) options.status = status;
+          if (date) options.date = date;
+          if (category_id) options.category_id = category_id;
+          if (author_id) options.author_id = author_id;
           const result2 = await this.apiClient.publishToWordPress(entity_id, options);
           this.metrics.recordAPICall("publish_wordpress", result2.success ? "success" : "error");
           if (result2.success) {
-            return { content: [{ type: "text", text: JSON.stringify({ success: true, message: "Content published to WordPress successfully", entity_id, wordpress_url: result2.url, status: options.status || "draft" }, null, 2) }] };
+            const response = {
+              success: true,
+              message: "Content published to WordPress successfully",
+              entity_id,
+              wordpress_url: result2.url,
+              status: status || "draft"
+            };
+            if (warnings.length > 0) response.warnings = warnings;
+            return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }] };
           } else {
             throw new Error(result2.error || "Publishing failed");
           }
         } catch (error) {
           logger.error("Failed to publish to WordPress", { error: error.message });
           this.metrics.recordAPICall("publish_wordpress", "error");
-          return { content: [{ type: "text", text: JSON.stringify({ error: true, message: error.message || "Failed to publish to WordPress" }, null, 2) }], isError: true };
+          const errorMsg = (error.message || "").toLowerCase();
+          const hints = [];
+          if (errorMsg.includes("rest_cannot_edit_others") || errorMsg.includes("403") || errorMsg.includes("cannot edit others")) {
+            hints.push("This error is likely caused by a stored publishwordpress_author value. Try again with clear_author: true to clear it before publishing.");
+          }
+          const response = { error: true, message: error.message || "Failed to publish to WordPress" };
+          if (hints.length > 0) response.hints = hints;
+          return { content: [{ type: "text", text: JSON.stringify(response, null, 2) }], isError: true };
         }
       }, "handler")
     };
@@ -2871,16 +3018,8 @@ var BulkOperationsToolHandler = class {
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          let processedArgs = { ...args };
-          if (typeof args.articles === "string") {
-            logger.info("Converting articles from string to array");
-            try {
-              processedArgs.articles = JSON.parse(args.articles);
-            } catch (error) {
-              throw new Error("Invalid articles format: expected array or JSON string");
-            }
-          }
-          const { articles, auto_generate = false } = processedArgs;
+          const articles = resolveArray(args, "articles");
+          const auto_generate = args.auto_generate ?? false;
           logger.info("Validating and transforming article data types", { count: articles.length });
           const validatedArticles = articles.map((article, index) => {
             try {
@@ -2994,17 +3133,23 @@ var BulkOperationsToolHandler = class {
       },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          let processedArgs = { ...args };
-          if (typeof args.articles === "string") {
-            logger.info("Converting articles from string to array (bulk cost estimate)");
-            try {
-              processedArgs.articles = JSON.parse(args.articles);
-            } catch (error) {
-              throw new Error("Invalid articles format: expected array or JSON string");
-            }
-          }
-          const { articles } = processedArgs;
+          const articles = resolveArray(args, "articles");
           const result2 = await this.apiClient.calculateBulkCost(articles);
+          logger.debug("bulk_estimate_cost raw API response keys", { keys: Object.keys(result2 || {}) });
+          const breakdown = result2?.breakdown ?? result2?.items ?? result2?.estimates ?? [];
+          let totalCredits;
+          if (typeof result2?.credits === "number" && !isNaN(result2.credits)) {
+            totalCredits = result2.credits;
+          } else if (typeof result2?.total === "number" && !isNaN(result2.total)) {
+            totalCredits = result2.total;
+          } else if (Array.isArray(breakdown) && breakdown.length > 0) {
+            totalCredits = breakdown.reduce((sum, item) => sum + (item?.credits ?? item?.cost ?? 0), 0);
+            logger.info("bulk_estimate_cost: totalCredits derived from breakdown sum", { totalCredits });
+          } else {
+            totalCredits = 0;
+            logger.warn("bulk_estimate_cost: could not extract credits from API response, defaulting to 0", { resultKeys: Object.keys(result2 || {}) });
+          }
+          const totalCost = typeof result2?.cost === "number" && !isNaN(result2.cost) ? result2.cost : typeof result2?.price === "number" && !isNaN(result2.price) ? result2.price : null;
           this.metrics.recordAPICall("bulk_estimate_cost", "success");
           return {
             content: [
@@ -3013,16 +3158,15 @@ var BulkOperationsToolHandler = class {
                 text: JSON.stringify({
                   success: true,
                   total_cost: {
-                    credits: result2.total,
-                    usd: (result2.total * 0.01).toFixed(2)
-                    // Assuming 1 credit = $0.01
+                    credits: totalCredits,
+                    usd: totalCost !== null ? totalCost.toFixed(2) : null
                   },
                   article_count: articles.length,
                   average_cost_per_article: {
-                    credits: Math.round(result2.total / articles.length),
-                    usd: (result2.total / articles.length * 0.01).toFixed(2)
+                    credits: articles.length > 0 ? Math.round(totalCredits / articles.length) : 0,
+                    usd: totalCost !== null && articles.length > 0 ? (totalCost / articles.length).toFixed(2) : null
                   },
-                  breakdown: result2.breakdown
+                  breakdown
                 }, null, 2)
               }
             ]
@@ -3647,7 +3791,7 @@ var CategoryPagesToolHandler = class {
           country: { type: "string", enum: [...COUNTRY_ENUM2], description: "Target country for localization" },
           project_id: { type: "string", format: "uuid", description: "Project UUID" },
           persona_id: { type: "string", format: "uuid", description: "Persona UUID" },
-          apply_project_brief_config: { type: "boolean", description: "Apply project configuration", default: false },
+          apply_project_brief_config: { type: "boolean", description: "Apply project configuration. When true with a project_id, lang/country will be inherited from the project if not explicitly provided.", default: false },
           use_faq: { type: "boolean", description: "Generate FAQ section", default: false },
           use_toc: { type: "boolean", description: "Generate table of contents", default: false },
           use_image: { type: "boolean", description: "Generate featured image", default: false },
@@ -3660,7 +3804,7 @@ var CategoryPagesToolHandler = class {
           publishwordpress_date: { type: "string", description: "Publication date (ISO 8601 or WordPress format)" },
           publishwordpress_status: { type: "string", enum: ["draft", "publish", "future"], description: "WordPress post status" },
           publishwordpress_category: { type: "number", description: "WordPress category ID" },
-          publishwordpress_author: { type: "number", description: "WordPress author ID" },
+          publishwordpress_author: { type: "number", description: "WordPress author ID. CAUTION: If the WP connection user lacks edit_others_posts capability, setting this will cause publishing to fail with rest_cannot_edit_others. Omit unless the WP user has admin/editor role." },
           publishwordpress_connection: { type: "string", format: "uuid", description: "WordPress connection UUID" }
         },
         required: ["name", "subject"]
@@ -3668,9 +3812,21 @@ var CategoryPagesToolHandler = class {
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
           const validated = CreateCategoryPageSchema.parse(args);
+          if (validated.apply_project_brief_config && validated.project_id && (!validated.lang || !validated.country)) {
+            try {
+              const project = await this.apiClient.getProject(validated.project_id);
+              if (!validated.lang && project.default_lang) {
+                validated.lang = project.default_lang;
+              }
+              if (!validated.country && project.default_country) {
+                validated.country = project.default_country;
+              }
+            } catch (e) {
+              logger.warn("Could not fetch project for lang/country defaults", { error: e.message });
+            }
+          }
           const input = this.buildApiInput(validated);
           const categoryPage = await this.apiClient.createCategoryPage(input);
-          await this.cache.set(`category_page:${categoryPage.id}`, categoryPage, 300);
           this.metrics.recordAPICall("create_category_page", "success");
           const displayName = categoryPage.name || validated.name || args.name || "Unnamed";
           return {
@@ -3838,10 +3994,19 @@ var CategoryPagesToolHandler = class {
     return {
       name: "estimate_category_page_cost",
       description: "Estimate the cost of generating a category page",
-      inputSchema: { type: "object", properties: { data: { type: "object", description: "Category page configuration for cost estimation" } }, required: ["data"] },
+      inputSchema: {
+        type: "object",
+        properties: {
+          subject: { type: "string", description: "Category page subject", minLength: 1 },
+          length: { oneOf: [{ type: "number", maximum: 5e3 }, { type: "string", const: "auto" }], default: "auto" },
+          use_image: { type: "boolean", default: false }
+        },
+        required: ["subject"]
+      },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const cost = await this.apiClient.calculateCategoryPageCost(args);
+          const costInput = args.data || args;
+          const cost = await this.apiClient.calculateCategoryPageCost(costInput);
           this.metrics.recordAPICall("estimate_category_page_cost", "success");
           return { content: [{ type: "text", text: JSON.stringify({ success: true, cost_estimate: cost }, null, 2) }] };
         } catch (error) {
@@ -3859,7 +4024,7 @@ var CategoryPagesToolHandler = class {
       inputSchema: { type: "object", properties: { items: { type: "array", items: { type: "object" }, description: "Array of category page configurations" } }, required: ["items"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { items } = args;
+          const items = resolveArray(args, "items");
           const result2 = await this.apiClient.createBulkCategoryPages(items);
           this.metrics.recordAPICall("bulk_create_category_pages", "success");
           return { content: [{ type: "text", text: JSON.stringify({ success: true, message: `Bulk created ${items.length} category pages`, result: result2 }, null, 2) }] };
@@ -3963,7 +4128,7 @@ var ProductPagesToolHandler = class {
           country: { type: "string", enum: [...COUNTRY_ENUM3], description: "Target country for localization" },
           project_id: { type: "string", format: "uuid", description: "Project UUID" },
           persona_id: { type: "string", format: "uuid", description: "Persona UUID" },
-          apply_project_brief_config: { type: "boolean", description: "Apply project configuration", default: false },
+          apply_project_brief_config: { type: "boolean", description: "Apply project configuration. When true with a project_id, lang/country will be inherited from the project if not explicitly provided.", default: false },
           use_faq: { type: "boolean", description: "Generate FAQ section", default: false },
           use_toc: { type: "boolean", description: "Generate table of contents", default: false },
           use_image: { type: "boolean", description: "Generate featured image", default: false },
@@ -3976,7 +4141,7 @@ var ProductPagesToolHandler = class {
           publishwordpress_date: { type: "string", description: "Publication date (ISO 8601 or WordPress format)" },
           publishwordpress_status: { type: "string", enum: ["draft", "publish", "future"], description: "WordPress post status" },
           publishwordpress_category: { type: "number", description: "WordPress category ID" },
-          publishwordpress_author: { type: "number", description: "WordPress author ID" },
+          publishwordpress_author: { type: "number", description: "WordPress author ID. CAUTION: If the WP connection user lacks edit_others_posts capability, setting this will cause publishing to fail with rest_cannot_edit_others. Omit unless the WP user has admin/editor role." },
           publishwordpress_connection: { type: "string", format: "uuid", description: "WordPress connection UUID" }
         },
         required: ["name", "subject"]
@@ -3984,9 +4149,21 @@ var ProductPagesToolHandler = class {
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
           const validated = CreateProductPageSchema.parse(args);
+          if (validated.apply_project_brief_config && validated.project_id && (!validated.lang || !validated.country)) {
+            try {
+              const project = await this.apiClient.getProject(validated.project_id);
+              if (!validated.lang && project.default_lang) {
+                validated.lang = project.default_lang;
+              }
+              if (!validated.country && project.default_country) {
+                validated.country = project.default_country;
+              }
+            } catch (e) {
+              logger.warn("Could not fetch project for lang/country defaults", { error: e.message });
+            }
+          }
           const input = this.buildApiInput(validated);
           const productPage = await this.apiClient.createProductPage(input);
-          await this.cache.set(`product_page:${productPage.id}`, productPage, 300);
           this.metrics.recordAPICall("create_product_page", "success");
           const displayName = productPage.name || validated.name || args.name || "Unnamed";
           return { content: [{ type: "text", text: JSON.stringify({ success: true, product_page_id: productPage.id, name: displayName, message: `Product page "${displayName}" created successfully`, next_steps: [`Use 'generate_product_page' with id: ${productPage.id}`, `Use 'get_product_page' with id: ${productPage.id}`] }, null, 2) }] };
@@ -4135,10 +4312,19 @@ var ProductPagesToolHandler = class {
     return {
       name: "estimate_product_page_cost",
       description: "Estimate the cost of generating a product page",
-      inputSchema: { type: "object", properties: { data: { type: "object", description: "Product page configuration for cost estimation" } }, required: ["data"] },
+      inputSchema: {
+        type: "object",
+        properties: {
+          subject: { type: "string", description: "Product page subject", minLength: 1 },
+          length: { oneOf: [{ type: "number", maximum: 5e3 }, { type: "string", const: "auto" }], default: "auto" },
+          use_image: { type: "boolean", default: false }
+        },
+        required: ["subject"]
+      },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const cost = await this.apiClient.calculateProductPageCost(args);
+          const costInput = args.data || args;
+          const cost = await this.apiClient.calculateProductPageCost(costInput);
           this.metrics.recordAPICall("estimate_product_page_cost", "success");
           return { content: [{ type: "text", text: JSON.stringify({ success: true, cost_estimate: cost }, null, 2) }] };
         } catch (error) {
@@ -4156,7 +4342,7 @@ var ProductPagesToolHandler = class {
       inputSchema: { type: "object", properties: { items: { type: "array", items: { type: "object" }, description: "Array of product page configurations" } }, required: ["items"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { items } = args;
+          const items = resolveArray(args, "items");
           const result2 = await this.apiClient.createBulkProductPages(items);
           this.metrics.recordAPICall("bulk_create_product_pages", "success");
           return { content: [{ type: "text", text: JSON.stringify({ success: true, message: `Bulk created ${items.length} product pages`, result: result2 }, null, 2) }] };
@@ -4277,7 +4463,7 @@ var DiscoverToolHandler = class {
           keywords_secondary: { type: "string", description: "Secondary keywords" },
           project_id: { type: "string", format: "uuid", description: "Project UUID" },
           persona_id: { type: "string", format: "uuid", description: "Persona UUID" },
-          apply_project_brief_config: { type: "boolean", description: "Apply project brief configuration settings. When true, inherits all feature flags and settings from the project brief (use_faq, use_toc, use_inline_images, internal links, etc.). Recommended for consistency.", default: false },
+          apply_project_brief_config: { type: "boolean", description: "Apply project brief configuration settings. When true, inherits all feature flags and settings from the project brief (use_faq, use_toc, use_inline_images, internal links, etc.). When true with a project_id, lang/country will be inherited from the project if not explicitly provided. Recommended for consistency.", default: false },
           lang: { type: "string", enum: ["fr", "en"], description: "Language code" },
           country: { type: "string", enum: ["fr", "be", "ch", "ca", "us", "gb"], description: "Country code" },
           length: { description: 'Number (max 2000) or "auto"' },
@@ -4319,7 +4505,7 @@ var DiscoverToolHandler = class {
           publishwordpress_date: { type: "string", description: "WordPress publish date" },
           publishwordpress_status: { type: "string", enum: ["draft", "publish", "future"], description: "WordPress post status" },
           publishwordpress_category: { type: "number", description: "WordPress category ID" },
-          publishwordpress_author: { type: "number", description: "WordPress author ID" },
+          publishwordpress_author: { type: "number", description: "WordPress author ID. CAUTION: If the WP connection user lacks edit_others_posts capability, setting this will cause publishing to fail with rest_cannot_edit_others. Omit unless the WP user has admin/editor role." },
           publishwordpress_connection: { type: "string", description: "WordPress connection ID" },
           // Additional features
           use_infotable: { type: "boolean", description: "Add info table" },
@@ -4344,6 +4530,19 @@ var DiscoverToolHandler = class {
             apply_project_brief_config_raw_type: typeof args.apply_project_brief_config
           });
           const validated = DiscoverContentSchema.parse(args);
+          if (validated.apply_project_brief_config && validated.project_id && (!validated.lang || !validated.country)) {
+            try {
+              const project = await this.apiClient.getProject(validated.project_id);
+              if (!validated.lang && project.default_lang) {
+                validated.lang = project.default_lang;
+              }
+              if (!validated.country && project.default_country) {
+                validated.country = project.default_country;
+              }
+            } catch (e) {
+              logger.warn("Could not fetch project for lang/country defaults", { error: e.message });
+            }
+          }
           logger.info("discover_content VALIDATED (after boolField transform)", {
             apply_project_brief_config: validated.apply_project_brief_config,
             apply_project_brief_config_type: typeof validated.apply_project_brief_config,
@@ -4363,7 +4562,6 @@ var DiscoverToolHandler = class {
             apply_project_brief_config_value: cleanedInput.apply_project_brief_config
           });
           const discovery = await this.apiClient.discoverArticles(cleanedInput);
-          await this.cache.set(`discover:${discovery.id}`, discovery, 300);
           this.metrics.recordAPICall("discover_content", "success");
           return {
             content: [{
@@ -4507,10 +4705,19 @@ var DiscoverToolHandler = class {
     return {
       name: "estimate_discover_cost",
       description: "Estimate the cost of a discover article",
-      inputSchema: { type: "object", properties: { data: { type: "object", description: "Discovery configuration for cost estimation" } }, required: ["data"] },
+      inputSchema: {
+        type: "object",
+        properties: {
+          subject: { type: "string", description: "Discover article subject", minLength: 1 },
+          length: { oneOf: [{ type: "number", maximum: 2e3 }, { type: "string", const: "auto" }], default: "auto" },
+          use_image: { type: "boolean", default: false }
+        },
+        required: ["subject"]
+      },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const cost = await this.apiClient.calculateDiscoverCost(args);
+          const costInput = args.data || args;
+          const cost = await this.apiClient.calculateDiscoverCost(costInput);
           this.metrics.recordAPICall("estimate_discover_cost", "success");
           return { content: [{ type: "text", text: JSON.stringify({ success: true, cost_estimate: cost }, null, 2) }] };
         } catch (error) {
@@ -4528,7 +4735,7 @@ var DiscoverToolHandler = class {
       inputSchema: { type: "object", properties: { items: { type: "array", items: { type: "object" }, description: "Array of discover article configurations" } }, required: ["items"] },
       handler: /* @__PURE__ */ __name(async (args) => {
         try {
-          const { items } = args;
+          const items = resolveArray(args, "items");
           const result2 = await this.apiClient.createBulkDiscoverArticles(items);
           this.metrics.recordAPICall("bulk_create_discover_articles", "success");
           return { content: [{ type: "text", text: JSON.stringify({ success: true, message: `Bulk created ${items.length} discover articles`, result: result2 }, null, 2) }] };
@@ -4621,8 +4828,10 @@ var RSSToolHandler = class {
         } catch (error) {
           logger.error("Failed to create feed", { error: error.message });
           this.metrics.recordAPICall("create_feed", "error");
+          const errorMessage = error.message || "Failed to create feed";
+          const guidance = "Please verify the feed URL is a valid RSS/Atom feed and is accessible. If the URL is correct, this may be a temporary Wisewand service issue \u2014 try again later.";
           return {
-            content: [{ type: "text", text: JSON.stringify({ error: true, message: error.message || "Failed to create feed", details: error.issues || void 0 }, null, 2) }],
+            content: [{ type: "text", text: JSON.stringify({ error: true, message: errorMessage, guidance, details: error.issues || void 0 }, null, 2) }],
             isError: true
           };
         }