@rolino/mcp 0.4.0 → 0.5.0-beta.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # @rolino/mcp
 
+## 0.5.0-beta.0
+
+### Minor Changes
+
+- 4f9e790: Add the optional `blog:manage` capability and synchronized agent-first Blog
+  setup, import, cadence planning, plan review, article creation, confirmed
+  connection provisioning, and safe verification operations.
+- 1edd1e7: Add published Blog Studio delivery contracts and the server-only Next.js 16 Blog Studio package.
+- 74a13ea: Expose immediate versus scheduled delivery and destination lifecycle stages,
+  preserve YouTube visibility for immediate publishing, and clarify remote
+  schedule confirmation across public clients.
+- 4a893dd: Add provider-neutral Blog publishing destinations, safe delivery inspection,
+  and exact destination binding across public agent interfaces.
+- 843a1db: Add the exact optional `seo:read` capability and bounded read-only SEO
+  opportunity and weekly-report parity across public agent contracts, clients,
+  CLI commands, and closed-world MCP tools. SEO reads now use the version 3 task
+  contract with the exact Ready, Research, or Rejected decision, selected format,
+  complete deliverables, bounded evidence, safe URLs, limitations, and no-publish
+  rules. Public output uses readable topic names and separate topic-relevance and
+  action-readiness confidence. Research tasks compare all supported formats and
+  must validate or reject the finding before a separate draft action is allowed.
+
+### Patch Changes
+
+- Updated dependencies [4f9e790]
+- Updated dependencies [1edd1e7]
+- Updated dependencies [74a13ea]
+- Updated dependencies [4a893dd]
+- Updated dependencies [843a1db]
+  - @rolino/contracts@0.5.0-beta.0
+  - @rolino/sdk@0.5.0-beta.0
+  - @rolino/local-auth@0.5.0-beta.0
+
+## Unreleased
+
+### Minor Changes
+
+- Add safe Blog provider, destination, and delivery tools plus destination-bound publication inputs.
+
 ## 0.4.0
 
 ### Minor Changes

package/README.md

@@ -37,6 +37,10 @@ Initial tools:
 - `execute_post_publish`
 - `list_integration_health`
 - `refresh_delivery_options`
+- `list_seo_opportunities`
+- `get_seo_opportunity`
+- `list_seo_reports`
+- `get_seo_report`
 - `list_calendar_events`
 
 The media tools discover reusable project assets and stream one explicitly
@@ -46,6 +50,19 @@ Uploading never creates, schedules, or publishes a post; the returned
 asset ID is passed into a later draft operation.
 
 The tool set includes discovery and inspection tools that are read-only.
+The four SEO tools require the exact optional `seo:read` capability. They are
+bounded, read-only, idempotent, and closed-world. They return canonical tasks,
+evidence, neutral provenance, separate topic-relevance and action-readiness
+confidence, and recommended actions. They cannot
+run analysis, change settings, delete data, enable reports, send email, or call
+an external provider.
+Opportunity detail also returns the bounded versioned task: exact decision,
+format, target, deliverables, research, safe URLs, evidence, limitations, and
+success metric. Ready can request final deliverables for human review. Research
+selects only `RESEARCH_TASK`, compares all reasonable formats without a
+preferred final format, and must return `VALIDATED` with a complete next task
+or `REJECTED` with evidence before any separately allowed draft
+action. Every copied task forbids publishing and other Rolino writes.
 `create_project` is an additive, closed-world mutation that requires
 `projects:write` and a caller-supplied idempotency key. It atomically saves the
 project and its paired brand without starting research, connecting accounts,
@@ -70,15 +87,15 @@ Direct drafts must make every declaration explicit and mark the choices
 reviewed only after inspecting this result. That review is distinct from MCP
 mutation consent. Changing TikTok content clears the prior review, and Rolino
 never silently turns off a requested interaction.
-For LinkedIn, `refresh_delivery_options` returns the connected member plus the
-strict text/single-image/multi-image/video policy and JPEG/PNG/MP4 limits.
-LinkedIn drafts can be text-only, contain up to ten stored images, or contain
-exactly one stored MP4 without mixing images and video. Native video must be
-75 KB to 500 MB and 3 seconds to 30 minutes, and execution remains in
-preparation until LinkedIn confirms upload and processing. An optional
-3,000-character LINKEDIN caption override uses the shared caption as fallback.
-The connected member is always the author; Company Page publishing is outside
-this contract.
+For LinkedIn, `refresh_delivery_options` returns the connected member plus the
+strict text/single-image/multi-image/video policy and JPEG/PNG/MP4 limits.
+LinkedIn drafts can be text-only, contain up to ten stored images, or contain
+exactly one stored MP4 without mixing images and video. Native video must be
+75 KB to 500 MB and 3 seconds to 30 minutes, and execution remains in
+preparation until LinkedIn confirms upload and processing. An optional
+3,000-character LINKEDIN caption override uses the shared caption as fallback.
+The connected member is always the author; Company Page publishing is outside
+this contract.
 Integration health is cached and secret-safe, post
 readiness reuses Rolino's publishing checks, and calendar reads use bounded
 date windows with cursor pagination. After `rolino auth login`, configure `ROLINO_URL` and
@@ -99,8 +116,10 @@ idempotency key. The server repeats readiness and live-health checks and rejects
 expired, consumed, stale, cross-credential, or mismatched confirmation.
 For YouTube, the preview explains that confirmed scheduling starts or resumes a
 private upload immediately so processing can complete before the Public target.
-Execution may return a typed `PENDING` result while the remote schedule is
-being confirmed; it does not report the video as published.
+Execution may return a typed `PENDING` result with phase
+`REMOTE_SCHEDULE_CONFIRMATION` after the upload completes while YouTube
+acknowledges the requested publish time. The video remains private, the result
+does not report it as published, and no second publish tool call is required.
 
 Immediate publishing also uses two tools. `preview_post_publish` checks the
 exact destination set, post version, readiness, live provider health, and retry
@@ -110,7 +129,10 @@ then durably queues the selected destinations for immediate delivery. Provider
 calls happen after that database commit, and Rolino's existing reconciliation
 rules block blind retries after ambiguous external results. YouTube remains
 `PREPARING` until upload and processing are provider-confirmed, and its exact
-configured visibility is reconciled before publication is reported.
+configured Public, Unlisted, or Private visibility is reconciled before
+publication is reported. The preview reports `deliveryMode: "IMMEDIATE"` and
+`createsSchedule: false`; immediate publishing never enters schedule
+confirmation.
 
 MCP tools cannot enable YouTube, Bluesky, or LinkedIn or bypass a deployment's
 provider approval boundary. Self-hosted operators should complete the
@@ -129,3 +151,31 @@ issues through the repository's
 [security policy](https://github.com/deifos/rolino/security/policy).
 
 `@rolino/mcp` is available under the MIT License.
+## Agent-first Blog Studio tools
+
+The local stdio server exposes Blog readiness, import, cadence planning,
+plan-item evidence and state, editable article creation, connection status,
+confirmed provisioning, signed revalidation testing, and these provider-neutral
+publishing reads:
+
+- `list_blog_publishing_providers` requires `blog:manage` and returns only
+  enabled providers, safe capabilities, and official documentation.
+- `list_blog_publishing_destinations` requires `blog:read` and returns safe
+  connection readiness without credentials or private provider data.
+- `list_blog_delivery_attempts` requires `blog:read`, accepts an optional exact
+  article ID, and returns safe delivery states, retry times, error codes, and
+  remote URLs.
+
+These three tools are closed-world reads. They do not contact a provider or
+change content. They do not return draft content, prompts, evidence, secrets,
+or raw provider responses. Setup requires the
+independent optional `blog:manage` capability; it is never inferred from
+`blog:write` or `blog:publish` and is not added to existing credentials.
+
+Read tools are closed-world. The signed revalidation test is accurately marked
+as an open-world write. Connection execute is confirmed, destructive, and
+idempotent; its first success may return one-time values that must be written
+only to server-side environment configuration. Errors and replays never reveal
+those values. These are local stdio tools—Rolino does not expose hosted remote
+MCP. Publication still requires a user-approved exact revision and the
+separate publish preview/execute tools.

package/dist/bin.cjs

@@ -52,7 +52,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",
@@ -111,9 +111,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: {
@@ -183,7 +183,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 = {
@@ -205,6 +205,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) {
@@ -304,6 +306,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",
@@ -314,6 +328,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,
@@ -535,7 +553,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."),
@@ -558,7 +576,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."),
@@ -590,7 +608,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."),
@@ -613,7 +631,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."),
@@ -677,6 +695,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.",