@rolino/mcp 0.4.0 → 0.5.0-beta.0

package/dist/index.cjs

@@ -48,7 +48,7 @@ var z = __toESM(require("zod/v4"), 1);
 // package.json
 var package_default = {
   name: "@rolino/mcp",
-  version: "0.4.0",
+  version: "0.5.0-beta.0",
   description: "Model Context Protocol server for Rolino",
   type: "module",
   license: "MIT",
@@ -107,9 +107,9 @@ var package_default = {
   dependencies: {
     "@hono/node-server": "2.0.12",
     "@modelcontextprotocol/sdk": "^1.30.0",
-    "@rolino/contracts": "0.4.0",
-    "@rolino/local-auth": "0.4.0",
-    "@rolino/sdk": "0.4.0",
+    "@rolino/contracts": "0.5.0-beta.0",
+    "@rolino/local-auth": "0.5.0-beta.0",
+    "@rolino/sdk": "0.5.0-beta.0",
     zod: "^4.4.3"
   },
   devDependencies: {
@@ -195,7 +195,7 @@ var mcpDraftInputShape = {
     "TikTok delivery choices. First call refresh_delivery_options, then supply an explicit mode. Direct publishing requires an exact returned visibility plus yes/no choices for comments, duet, stitch, commercial content, own-brand promotion, third-party promotion, and AI-generated content. Set reviewed only after reviewing the account-specific options; this is distinct from draft mutation consent."
   ),
   youtubeSettings: import_contracts.DraftPostInputSchema.shape.youtubeSettings.describe(
-    "Required with YOUTUBE: explicit title, numeric categoryId, privacyStatus, madeForKids declaration, synthetic-media disclosure, subscriber-notification choice, and tags. Unaudited Google API projects may be restricted to Private uploads."
+    "Required with YOUTUBE: explicit title, numeric categoryId, privacyStatus, madeForKids declaration, synthetic-media disclosure, subscriber-notification choice, and tags. Immediate publishing uses the exact PUBLIC, UNLISTED, or PRIVATE visibility and creates no schedule. Future scheduling requires PUBLIC, while Rolino uploads privately for preparation. Unaudited Google API projects may be restricted to Private uploads."
   )
 };
 var mcpDraftUpdateInputShape = {
@@ -217,6 +217,8 @@ var mcpScheduleExecuteOutputSchema = z.object({
   provider: import_contracts.PostSchedulePendingSchema.shape.provider.optional(),
   mutationId: import_contracts.PostSchedulePendingSchema.shape.mutationId.optional(),
   operation: import_contracts.PostSchedulePendingSchema.shape.operation.optional(),
+  phase: import_contracts.PostSchedulePendingSchema.shape.phase.optional(),
+  videoUploaded: import_contracts.PostSchedulePendingSchema.shape.videoUploaded.optional(),
   message: import_contracts.PostSchedulePendingSchema.shape.message.optional()
 }).passthrough();
 function jsonResult(structuredContent) {
@@ -316,6 +318,18 @@ var publishExecuteAnnotations = {
   idempotentHint: true,
   openWorldHint: true
 };
+var destructiveIdempotentAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: true,
+  idempotentHint: true,
+  openWorldHint: false
+};
+var revalidationTestAnnotations = {
+  readOnlyHint: false,
+  destructiveHint: false,
+  idempotentHint: true,
+  openWorldHint: true
+};
 function defaultClient(options) {
   return new import_sdk2.RolinoClient({
     baseUrl: options.baseUrl ?? "https://getrolino.com",
@@ -326,6 +340,10 @@ function defaultClient(options) {
 }
 function createRolinoMcpServer(options = {}) {
   const api = options.client ?? defaultClient(options);
+  const blogApi = () => {
+    if (!api.blog) throw new TypeError("This Rolino client does not support Blog Studio.");
+    return api.blog;
+  };
   const server = new import_mcp.McpServer({
     name: "rolino",
     version: ROLINO_MCP_VERSION,
@@ -547,7 +565,7 @@ function createRolinoMcpServer(options = {}) {
   });
   server.registerTool("preview_post_schedule", {
     title: "Preview a Rolino post schedule",
-    description: "Validate one exact future schedule against the current post version and live provider health. A YouTube schedule must target Public and its preview explains that confirmed execution starts a private upload immediately for early processing. This contacts configured providers and creates a five-minute, single-use confirmation, but does not schedule or publish the post. Inspect the complete result before calling execute_post_schedule with identical values.",
+    description: "Validate one exact future schedule against the current post version and live provider health. A YouTube schedule must target Public. Its preview states that preparation uploads the video privately now; CONFIRMING_SCHEDULE means the upload is complete and YouTube is acknowledging the future Public publish time, not that the video is public. This contacts configured providers and creates a five-minute, single-use confirmation, but does not schedule or publish the post. Inspect the complete result before calling execute_post_schedule with identical values.",
     inputSchema: {
       projectId: z.string().min(1).describe("Exact Rolino project ID."),
       postId: z.string().min(1).describe("Exact Rolino post ID."),
@@ -570,7 +588,7 @@ function createRolinoMcpServer(options = {}) {
   });
   server.registerTool("execute_post_schedule", {
     title: "Execute a confirmed Rolino post schedule",
-    description: "Schedule a post only after preview_post_schedule. Pass the unchanged time, timezone, post version, and returned one-time confirmation token. For YouTube, confirmed execution begins or resumes the private upload immediately and may return PENDING until a remote schedule change is confirmed; it never means the video already published. Rolino rechecks readiness and provider health, rejects stale or mismatched confirmation, and uses the stable idempotency key for safe retries. Scheduling causes future external publishing and is consequential.",
+    description: "Schedule a post only after preview_post_schedule. Pass the unchanged time, timezone, post version, and returned one-time confirmation token. For YouTube, confirmed execution begins or resumes a private upload immediately and may return PENDING with phase REMOTE_SCHEDULE_CONFIRMATION after upload while YouTube acknowledges the future Public publish time. PENDING never means the video is public. Rolino rechecks readiness and provider health, rejects stale or mismatched confirmation, and uses the stable idempotency key for safe retries. Scheduling causes future external publishing and is consequential.",
     inputSchema: {
       projectId: z.string().min(1).describe("Exact Rolino project ID."),
       postId: z.string().min(1).describe("Exact Rolino post ID."),
@@ -602,7 +620,7 @@ function createRolinoMcpServer(options = {}) {
   });
   server.registerTool("preview_post_publish", {
     title: "Preview immediate Rolino post publishing",
-    description: "Validate exact destinations against the current post version, safe retry state, readiness, and live provider health. YouTube readiness requires one stored video and explicit metadata; the configured visibility is exact, while unaudited Google API projects may be restricted to Private. This contacts configured providers and creates a five-minute, single-use confirmation, but does not publish. Inspect the complete result before calling execute_post_publish with identical destinations.",
+    description: "Validate exact destinations for immediate publishing against the current post version, safe retry state, readiness, and live provider health. YouTube readiness requires one stored video and explicit metadata. Immediate YouTube publishing uses the configured PUBLIC, UNLISTED, or PRIVATE visibility and never creates a schedule; the preview exposes this as deliveryMode IMMEDIATE. Unaudited Google API projects may be restricted to Private. This contacts configured providers and creates a five-minute, single-use confirmation, but does not publish. Inspect the complete result before calling execute_post_publish with identical destinations.",
     inputSchema: {
       projectId: z.string().min(1).describe("Exact Rolino project ID."),
       postId: z.string().min(1).describe("Exact Rolino post ID."),
@@ -625,7 +643,7 @@ function createRolinoMcpServer(options = {}) {
   });
   server.registerTool("execute_post_publish", {
     title: "Execute confirmed immediate Rolino post publishing",
-    description: "Begin external publishing only after preview_post_publish. Pass the unchanged destinations, post version, and returned one-time confirmation token. Video execution remains PREPARING for YouTube and LinkedIn until provider-confirmed upload and processing complete; no queued or local state is reported as published. Rolino rechecks readiness and safe retry state, durably queues the exact destinations, rejects ambiguous prior outcomes, and uses the stable idempotency key to prevent duplicate execution. This is immediately consequential.",
+    description: "Begin external publishing only after preview_post_publish. Pass the unchanged destinations, post version, and returned one-time confirmation token. Immediate YouTube publishing preserves the previewed PUBLIC, UNLISTED, or PRIVATE visibility and never creates or confirms a schedule. Video execution remains PREPARING for YouTube and LinkedIn until provider-confirmed upload and processing complete; no queued or local state is reported as published. Rolino rechecks readiness and safe retry state, durably queues the exact destinations, rejects ambiguous prior outcomes, and uses the stable idempotency key to prevent duplicate execution. This is immediately consequential.",
     inputSchema: {
       projectId: z.string().min(1).describe("Exact Rolino project ID."),
       postId: z.string().min(1).describe("Exact Rolino post ID."),
@@ -689,6 +707,379 @@ function createRolinoMcpServer(options = {}) {
       return errorResult(error);
     }
   });
+  server.registerTool("list_seo_opportunities", {
+    title: "List active SEO tasks",
+    description: "Read a bounded list of active Ready and Research SEO tasks for one exact project. Each result contains one complete versioned task, decision, format, deliverables, evidence, provenance, separate topic-relevance and action-readiness confidence, limits, and no-publish rules. Rejected findings are never active tasks. This closed-world tool cannot run analysis, change settings, delete data, enable reports, send email, publish, generate media, or call an external provider.",
+    inputSchema: {
+      projectId: import_contracts.SeoEntityIdSchema.describe("Exact Rolino project ID."),
+      limit: z.number().int().min(1).max(50).default(20).describe("Maximum opportunities to return, from 1 to 50."),
+      cursor: z.string().min(1).max(512).regex(/^[A-Za-z0-9_-]+$/).optional().describe("Opaque cursor returned by a previous list_seo_opportunities call."),
+      kind: import_contracts.SeoOpportunityKindSchema.optional().describe("Optional exact opportunity kind."),
+      expectedImpact: import_contracts.SeoExpectedImpactSchema.optional().describe("Optional HIGH, MEDIUM, or LOW impact filter.")
+    },
+    outputSchema: import_contracts.SeoOpportunityListDataSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, limit, cursor, kind, expectedImpact }) => {
+    try {
+      if (!api.seo) throw new TypeError("This Rolino client does not support SEO reading.");
+      return jsonResult(await api.seo.opportunities.list(projectId, { limit, cursor, kind, expectedImpact }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("get_seo_opportunity", {
+    title: "Read one complete SEO task",
+    description: "Read one canonical versioned SEO task by exact project and opportunity ID. It includes the Ready or Research decision, selected format, exact deliverables, safe evidence, provenance, separate topic-relevance and action-readiness confidence, targeting, source dates, limitations, success metric, and no-publish rules. This closed-world tool is read-only and cannot generate content, publish, or call an external provider.",
+    inputSchema: {
+      projectId: import_contracts.SeoEntityIdSchema.describe("Exact Rolino project ID."),
+      opportunityId: import_contracts.SeoEntityIdSchema.describe("Exact Rolino SEO opportunity ID.")
+    },
+    outputSchema: import_contracts.SeoOpportunitySchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, opportunityId }) => {
+    try {
+      if (!api.seo) throw new TypeError("This Rolino client does not support SEO reading.");
+      return jsonResult(await api.seo.opportunities.get(projectId, opportunityId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_seo_reports", {
+    title: "List weekly SEO reports",
+    description: "Read a bounded list of stored weekly SEO report summaries for one exact project. This closed-world tool is read-only and cannot generate or deliver reports.",
+    inputSchema: {
+      projectId: import_contracts.SeoEntityIdSchema.describe("Exact Rolino project ID."),
+      limit: z.number().int().min(1).max(26).default(10).describe("Maximum reports to return, from 1 to 26."),
+      cursor: z.string().min(1).max(512).regex(/^[A-Za-z0-9_-]+$/).optional().describe("Opaque cursor returned by a previous list_seo_reports call."),
+      completeness: import_contracts.SeoReportCompletenessSchema.optional().describe("Optional COMPLETE or PARTIAL filter.")
+    },
+    outputSchema: import_contracts.SeoReportListDataSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, limit, cursor, completeness }) => {
+    try {
+      if (!api.seo) throw new TypeError("This Rolino client does not support SEO reading.");
+      return jsonResult(await api.seo.reports.list(projectId, { limit, cursor, completeness }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("get_seo_report", {
+    title: "Read one weekly SEO report",
+    description: "Read one unchanged weekly SEO report snapshot by exact project and report ID. It groups complete Ready tasks, Research tasks, and bounded rejected findings. This closed-world tool is read-only and cannot generate content, change, or deliver a report.",
+    inputSchema: {
+      projectId: import_contracts.SeoEntityIdSchema.describe("Exact Rolino project ID."),
+      reportId: import_contracts.SeoEntityIdSchema.describe("Exact Rolino weekly SEO report ID.")
+    },
+    outputSchema: import_contracts.SeoReportSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, reportId }) => {
+    try {
+      if (!api.seo) throw new TypeError("This Rolino client does not support SEO reading.");
+      return jsonResult(await api.seo.reports.get(projectId, reportId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_blog_plans", {
+    title: "List Blog Studio plans",
+    description: "Read the bounded 30-day Blog Studio plans for one exact project. This does not read the social calendar.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema.describe("Exact Rolino project ID.") },
+    outputSchema: z.object({ plans: z.array(import_contracts.AgentBlogPlanSchema) }),
+    annotations: readOnlyAnnotations
+  }, async ({ projectId }) => {
+    try {
+      return jsonResult(await blogApi().plans.list(projectId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("get_blog_setup_status", {
+    title: "Get Blog setup status",
+    description: "Requires blog:read. Call first to inspect action-oriented website, import, plan, delivery, and revalidation readiness. This never returns credentials, secrets, prompts, or draft content.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema },
+    outputSchema: import_contracts.AgentBlogSetupStatusSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId }) => {
+    try {
+      return jsonResult(await blogApi().setup.status(projectId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("initialize_blog_site", {
+    title: "Initialize and import Blog site",
+    description: "Requires blog:manage. Initialize the exact project website from Brand Settings and queue a bounded import. Poll the returned job; do not retry blindly. This cannot publish.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, idempotencyKey: z.string().min(8).max(200) },
+    outputSchema: import_contracts.AgentBlogJobSchema,
+    annotations: createDraftAnnotations
+  }, async ({ projectId, idempotencyKey }) => {
+    try {
+      return jsonResult(await blogApi().site.import(projectId, idempotencyKey));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("retry_blog_site_import", {
+    title: "Retry Blog site import",
+    description: "Requires blog:manage. Requeue only a failed bounded website import with a stable idempotency key. Poll the returned job.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, idempotencyKey: z.string().min(8).max(200) },
+    outputSchema: import_contracts.AgentBlogJobSchema,
+    annotations: createDraftAnnotations
+  }, async ({ projectId, idempotencyKey }) => {
+    try {
+      return jsonResult(await blogApi().site.retry(projectId, idempotencyKey));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("create_blog_plan", {
+    title: "Create Blog cadence plan",
+    description: "Requires blog:manage. Queue an evidence-backed 30-day plan only after import is ready. Ask the user for cadence first and poll the returned job. This never accepts items or publishes.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, startsOn: z.string().regex(/^\d{4}-\d{2}-\d{2}$/), weekdays: z.array(z.number().int().min(0).max(6)).min(1).max(7), timeZone: z.string().min(1), idempotencyKey: z.string().min(8).max(200) },
+    outputSchema: z.object({ planId: z.string(), job: import_contracts.AgentBlogJobSchema }),
+    annotations: createDraftAnnotations
+  }, async ({ projectId, startsOn, weekdays, timeZone, idempotencyKey }) => {
+    try {
+      return jsonResult(await blogApi().plans.create(projectId, { startsOn, weekdays, timeZone }, idempotencyKey));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("retry_blog_plan", {
+    title: "Retry failed Blog plan",
+    description: "Requires blog:manage. Retry one exact failed plan generation with idempotency and poll the returned job.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, planId: import_contracts.SeoEntityIdSchema, idempotencyKey: z.string().min(8).max(200) },
+    outputSchema: import_contracts.AgentBlogJobSchema,
+    annotations: createDraftAnnotations
+  }, async ({ projectId, planId, idempotencyKey }) => {
+    try {
+      return jsonResult(await blogApi().plans.retry(projectId, planId, idempotencyKey));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_blog_plan_items", {
+    title: "List Blog plan items and evidence",
+    description: "Requires blog:read. Present this safe frozen evidence to the user before accepting or dismissing any item. Provider payloads and prompts are excluded.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, planId: import_contracts.SeoEntityIdSchema },
+    outputSchema: z.object({ items: z.array(import_contracts.AgentBlogPlanItemSchema) }),
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, planId }) => {
+    try {
+      return jsonResult(await blogApi().plans.items.list(projectId, planId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("set_blog_plan_item_state", {
+    title: "Accept or dismiss Blog plan item",
+    description: "Requires blog:write. Apply an optimistic, idempotent ACCEPTED or DISMISSED transition only after showing the evidence. Dismissal is marked destructive. This cannot publish.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, planId: import_contracts.SeoEntityIdSchema, itemId: import_contracts.SeoEntityIdSchema, state: z.enum(["ACCEPTED", "DISMISSED"]), expectedState: z.string().min(1), expectedVersion: z.number().int().positive(), idempotencyKey: z.string().min(8).max(200) },
+    outputSchema: import_contracts.AgentBlogPlanItemSchema,
+    annotations: destructiveIdempotentAnnotations
+  }, async ({ projectId, planId, itemId, ...input }) => {
+    try {
+      return jsonResult(await blogApi().plans.items.setState(projectId, planId, itemId, input));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("create_blog_article_from_plan_item", {
+    title: "Create editable Blog article",
+    description: "Requires blog:write. Create an editable draft from one accepted plan item and queue generation. Publication remains a separate approved-revision preview and execute operation.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, planId: import_contracts.SeoEntityIdSchema, itemId: import_contracts.SeoEntityIdSchema, expectedVersion: z.number().int().positive(), idempotencyKey: z.string().min(8).max(200) },
+    outputSchema: z.object({ articleId: z.string(), job: import_contracts.AgentBlogJobSchema.nullable() }),
+    annotations: createDraftAnnotations
+  }, async ({ projectId, planId, itemId, expectedVersion, idempotencyKey }) => {
+    try {
+      return jsonResult(await blogApi().plans.items.createArticle(projectId, planId, itemId, { expectedState: "ACCEPTED", expectedVersion, idempotencyKey }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("get_blog_connection_status", {
+    title: "Get Blog delivery connection status",
+    description: "Requires blog:read. Read configured and honestly verified delivery/revalidation readiness. It never returns stored tokens or secrets.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema },
+    outputSchema: import_contracts.AgentBlogConnectionStatusSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId }) => {
+    try {
+      return jsonResult(await blogApi().connection.status(projectId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  const connectionInputSchema = { projectId: import_contracts.SeoEntityIdSchema, endpoint: z.string().url().nullable(), credentialAction: z.enum(["KEEP", "CREATE", "ROTATE", "REVOKE"]), credentialId: z.string().min(1).nullable(), secretAction: z.enum(["KEEP", "CREATE", "ROTATE"]) };
+  server.registerTool("preview_blog_connection_setup", {
+    title: "Preview Blog connection setup",
+    description: "Requires blog:manage. Preview the exact site, endpoint, credential action, secret action, and effects before provisioning. No delivery token or webhook secret is returned by preview.",
+    inputSchema: connectionInputSchema,
+    outputSchema: import_contracts.AgentBlogConnectionPreviewSchema,
+    annotations: createDraftAnnotations
+  }, async ({ projectId, ...input }) => {
+    try {
+      return jsonResult(await blogApi().connection.preview(projectId, input));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("execute_blog_connection_setup", {
+    title: "Execute confirmed Blog connection setup",
+    description: "Requires blog:manage, the exact preview confirmation, and idempotency. A successful first response can return a delivery token or webhook secret once; write them only to server-side environment configuration. A replay never reveals them again. This cannot publish.",
+    inputSchema: { ...connectionInputSchema, confirmationToken: z.string().min(1), idempotencyKey: z.string().min(8).max(200) },
+    outputSchema: import_contracts.AgentBlogConnectionExecuteSchema,
+    annotations: destructiveIdempotentAnnotations
+  }, async ({ projectId, ...input }) => {
+    try {
+      return jsonResult(await blogApi().connection.execute(projectId, input));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("test_blog_revalidation", {
+    title: "Test signed Blog revalidation",
+    description: "Requires blog:manage. Make one explicit, SSRF-protected open-world signed request to the configured same-host endpoint and persist only a safe status code.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, idempotencyKey: z.string().min(8).max(200) },
+    outputSchema: import_contracts.AgentBlogRevalidationTestSchema,
+    annotations: revalidationTestAnnotations
+  }, async ({ projectId, idempotencyKey }) => {
+    try {
+      return jsonResult(await blogApi().connection.test(projectId, idempotencyKey));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_blog_publishing_providers", {
+    title: "List Blog publishing providers",
+    description: "List only providers available to this rollout with safe capabilities and official documentation. Requires blog:manage.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema },
+    outputSchema: z.object({ providers: z.array(import_contracts.AgentBlogPublishingProviderSchema) }),
+    annotations: readOnlyAnnotations
+  }, async ({ projectId }) => {
+    try {
+      return jsonResult(await blogApi().publishing.providers(projectId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_blog_publishing_destinations", {
+    title: "List Blog publishing destinations",
+    description: "List safe destination readiness without credentials or private provider data.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema },
+    outputSchema: z.object({ destinations: z.array(import_contracts.AgentBlogPublishingDestinationSchema) }),
+    annotations: readOnlyAnnotations
+  }, async ({ projectId }) => {
+    try {
+      return jsonResult(await blogApi().publishing.destinations(projectId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_blog_delivery_attempts", {
+    title: "List Blog delivery attempts",
+    description: "List safe per-destination delivery states and remote URLs. Draft content and provider responses are not returned.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, articleId: import_contracts.SeoEntityIdSchema.optional() },
+    outputSchema: z.object({ deliveries: z.array(import_contracts.AgentBlogDeliveryAttemptSchema) }),
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, articleId }) => {
+    try {
+      return jsonResult(await blogApi().publishing.deliveries(projectId, articleId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("list_blog_articles", {
+    title: "List Blog Studio articles",
+    description: "Read Blog Studio article workflow state for one exact project. Draft content requires blog:read.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema.describe("Exact Rolino project ID.") },
+    outputSchema: z.object({ articles: z.array(import_contracts.AgentBlogArticleSchema) }),
+    annotations: readOnlyAnnotations
+  }, async ({ projectId }) => {
+    try {
+      return jsonResult(await blogApi().articles.list(projectId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("get_blog_article", {
+    title: "Read one Blog Studio article",
+    description: "Read one exact Blog Studio draft and its immutable revision history.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, articleId: import_contracts.SeoEntityIdSchema },
+    outputSchema: import_contracts.AgentBlogArticleDetailSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, articleId }) => {
+    try {
+      return jsonResult(await blogApi().articles.get(projectId, articleId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("update_blog_draft", {
+    title: "Update one Blog Studio draft",
+    description: "Save a complete Blog draft with optimistic conflict protection. This creates a new immutable revision and cannot publish.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, articleId: import_contracts.SeoEntityIdSchema, draft: import_contracts.AgentBlogDraftUpdateSchema },
+    outputSchema: import_contracts.AgentBlogArticleDetailSchema,
+    annotations: createDraftAnnotations
+  }, async ({ projectId, articleId, draft }) => {
+    try {
+      return jsonResult(await blogApi().articles.updateDraft(projectId, articleId, draft));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("generate_blog_article", {
+    title: "Request Blog article generation",
+    description: "Queue durable generation for one Blog article. It returns a job and never waits for provider work in the request.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, articleId: import_contracts.SeoEntityIdSchema, idempotencyKey: z.string().min(8).max(200) },
+    outputSchema: import_contracts.AgentBlogJobSchema,
+    annotations: createDraftAnnotations
+  }, async ({ projectId, articleId, idempotencyKey }) => {
+    try {
+      return jsonResult(await blogApi().articles.generate(projectId, articleId, idempotencyKey));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("get_blog_job", {
+    title: "Read one Blog job",
+    description: "Read truthful durable job state without exposing prompts, provider details, or secrets.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, jobId: import_contracts.SeoEntityIdSchema },
+    outputSchema: import_contracts.AgentBlogJobSchema,
+    annotations: readOnlyAnnotations
+  }, async ({ projectId, jobId }) => {
+    try {
+      return jsonResult(await blogApi().jobs.get(projectId, jobId));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("preview_blog_publish", {
+    title: "Preview approved Blog publication",
+    description: "Preview an exact user-approved revision and issue a short-lived bound confirmation. This does not publish.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, articleId: import_contracts.SeoEntityIdSchema, revisionId: import_contracts.SeoEntityIdSchema, destinationIds: z.array(import_contracts.SeoEntityIdSchema).min(1).max(20).optional() },
+    outputSchema: import_contracts.AgentBlogPublishPreviewSchema,
+    annotations: publishPreviewAnnotations
+  }, async ({ projectId, articleId, revisionId, destinationIds }) => {
+    try {
+      return jsonResult(await blogApi().articles.previewPublish(projectId, articleId, revisionId, void 0, destinationIds));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
+  server.registerTool("execute_blog_publish", {
+    title: "Publish approved Blog revision",
+    description: "Publish only the same exact user-approved revision from preview. Requires blog:publish, a confirmation token, and an idempotency key.",
+    inputSchema: { projectId: import_contracts.SeoEntityIdSchema, articleId: import_contracts.SeoEntityIdSchema, revisionId: import_contracts.SeoEntityIdSchema, destinationIds: z.array(import_contracts.SeoEntityIdSchema).min(1).max(20).optional(), confirmationToken: z.string().min(1), idempotencyKey: z.string().min(8).max(200) },
+    outputSchema: z.object({ publicationId: z.string(), articleId: z.string(), revisionId: z.string(), publicUrl: z.string().url(), publishedAt: z.string().datetime() }),
+    annotations: publishExecuteAnnotations
+  }, async ({ projectId, articleId, revisionId, destinationIds, confirmationToken, idempotencyKey }) => {
+    try {
+      return jsonResult(await blogApi().articles.executePublish(projectId, articleId, { revisionId, destinationIds, confirmationToken, idempotencyKey }));
+    } catch (error) {
+      return errorResult(error);
+    }
+  });
   server.registerTool("list_calendar_events", {
     title: "List Rolino calendar events",
     description: "List scheduled posts and their enabled destinations in one exact project, including YouTube posts whose private early preparation has started. By default the bounded window spans 30 days in the past through 90 days ahead; provide both from and to for another range and paginate with nextCursor.",