@tool-bridge/server 0.21.1 → 0.22.1

package/dist/postmark-QJV5PHUQ.js

@@ -0,0 +1,427 @@
+import {
+  createAuthedClient
+} from "./chunk-RTW5VRTK.js";
+import "./chunk-BNMLA2RC.js";
+import {
+  asJsonObject,
+  compactDefined,
+  trimmedText
+} from "./chunk-JXHMDBAY.js";
+import {
+  createProviderPlugin,
+  upstreamError
+} from "./chunk-X7ZUTKHR.js";
+import "./chunk-7ISGFRC6.js";
+import "./chunk-UY6ANCOY.js";
+import {
+  TBError
+} from "./chunk-HA4BGL6C.js";
+import "./chunk-U67V476Y.js";
+
+// ../plugins/src/postmark/api.ts
+var SERVICE = "postmark";
+var API_BASE = "https://api.postmarkapp.com";
+var INVALID_TOKEN_CODE = 10;
+var NOT_FOUND_CODES = /* @__PURE__ */ new Set([12, 701, 1001, 1101]);
+var ACCOUNT_BLOCKED_CODES = /* @__PURE__ */ new Set([405, 412, 413]);
+function responseError(message) {
+  return new TBError("unavailable", message, { retryable: true });
+}
+function required(value, field) {
+  const result = trimmedText(value);
+  if (result === void 0) throw new TBError("invalid_argument", `${field} \u662F\u5FC5\u586B\u7684`);
+  return result;
+}
+function pathValue(value, field) {
+  if (typeof value === "number" && Number.isInteger(value) && value > 0) return String(value);
+  return required(value, field);
+}
+function postmarkError(status, payload) {
+  const message = trimmedText(payload.Message) ?? `Postmark \u8FD4\u56DE HTTP ${status}`;
+  const code = typeof payload.ErrorCode === "number" ? payload.ErrorCode : void 0;
+  if (code !== void 0) {
+    if (code === INVALID_TOKEN_CODE) return upstreamError(401, message);
+    if (NOT_FOUND_CODES.has(code)) return upstreamError(404, message);
+    if (ACCOUNT_BLOCKED_CODES.has(code)) return upstreamError(403, message);
+  }
+  return upstreamError(status, message);
+}
+var http = createAuthedClient({
+  baseUrl: API_BASE,
+  service: SERVICE,
+  auth: { kind: "header", name: "x-postmark-server-token" },
+  headers: { accept: "application/json" },
+  // ErrorCode 码表比 HTTP 状态准(见文件头),整段覆写而不用标准键序提取。
+  mapError: ({ bodyKind, data: payload, status }) => postmarkError(
+    status,
+    bodyKind === "json" ? asJsonObject(payload) ?? {} : bodyKind === "empty" ? {} : { Message: payload }
+  )
+});
+async function request(ctx, input) {
+  const { data } = await http.request(ctx, {
+    path: input.path,
+    method: input.method ?? "GET",
+    query: Object.entries(input.query ?? {}),
+    ...input.body === void 0 ? {} : { json: input.body },
+    invalidJsonMessage: "Postmark \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94"
+  });
+  if (data === void 0) throw responseError("Postmark \u8FD4\u56DE\u4E86\u975E JSON \u54CD\u5E94");
+  return data;
+}
+function getServer(_input, ctx) {
+  return request(ctx, { path: "/server" });
+}
+function sendEmail(input, ctx) {
+  return request(ctx, { path: "/email", method: "POST", body: compactDefined({ ...input }) });
+}
+function sendEmailWithTemplate(input, ctx) {
+  return request(ctx, { path: "/email/withTemplate", method: "POST", body: compactDefined({ ...input }) });
+}
+function sendBatchWithTemplates(input, ctx) {
+  return request(ctx, { path: "/email/batchWithTemplates", method: "POST", body: { Messages: input.Messages } });
+}
+function searchOutboundMessages(input, ctx) {
+  const metadata = input.metadata ?? {};
+  return request(ctx, {
+    path: "/messages/outbound",
+    query: {
+      ...compactDefined({
+        count: input.count,
+        offset: input.offset,
+        recipient: trimmedText(input.recipient),
+        fromemail: trimmedText(input.fromemail),
+        tag: trimmedText(input.tag),
+        status: trimmedText(input.status),
+        todate: trimmedText(input.todate),
+        fromdate: trimmedText(input.fromdate),
+        subject: trimmedText(input.subject),
+        messagestream: trimmedText(input.messagestream)
+      }),
+      // metadata 过滤器摊平成 metadata_<key>=<value>;空值的键整个不发。
+      ...Object.fromEntries(
+        Object.entries(metadata).flatMap(([key, value]) => {
+          const item = trimmedText(value);
+          return item === void 0 ? [] : [[`metadata_${key}`, item]];
+        })
+      )
+    }
+  });
+}
+function getOutboundMessageDetails(input, ctx) {
+  const messageId = required(input.messageId, "messageId");
+  return request(ctx, { path: `/messages/outbound/${encodeURIComponent(messageId)}/details` });
+}
+function getBounces(input, ctx) {
+  return request(ctx, {
+    path: "/bounces",
+    query: compactDefined({
+      count: input.count,
+      offset: input.offset,
+      type: trimmedText(input.type),
+      // `inactive: false` 是一个有意义的筛选值,不能被当成"没给"丢掉。
+      inactive: input.inactive,
+      emailFilter: trimmedText(input.emailFilter),
+      messageID: trimmedText(input.messageID),
+      mailboxHash: trimmedText(input.mailboxHash),
+      tag: trimmedText(input.tag),
+      todate: trimmedText(input.todate),
+      fromdate: trimmedText(input.fromdate)
+    })
+  });
+}
+function listTemplates(input, ctx) {
+  return request(ctx, {
+    path: "/templates",
+    query: compactDefined({
+      count: input.count,
+      offset: input.offset,
+      TemplateType: trimmedText(input.TemplateType),
+      LayoutTemplate: trimmedText(input.LayoutTemplate)
+    })
+  });
+}
+function getTemplate(input, ctx) {
+  const id = pathValue(input.templateIdOrAlias, "templateIdOrAlias");
+  return request(ctx, { path: `/templates/${encodeURIComponent(id)}` });
+}
+function createTemplate(input, ctx) {
+  return request(ctx, { path: "/templates", method: "POST", body: compactDefined({ ...input }) });
+}
+function editTemplate(input, ctx) {
+  const { templateIdOrAlias, ...rest } = input;
+  const id = pathValue(templateIdOrAlias, "templateIdOrAlias");
+  return request(ctx, { path: `/templates/${encodeURIComponent(id)}`, method: "PUT", body: compactDefined({ ...rest }) });
+}
+function validateTemplate(input, ctx) {
+  return request(ctx, { path: "/templates/validate", method: "POST", body: compactDefined({ ...input }) });
+}
+
+// ../plugins/src/postmark/schema.ts
+import { z } from "zod/v4";
+var getServerInput = z.strictObject({});
+var getServerOutput = z.looseObject({}).describe("Additional upstream fields returned by Postmark.");
+var sendEmailInput = z.strictObject({
+  From: z.string().min(1).describe("Sender email address or full formatted sender string accepted by Postmark."),
+  To: z.string().min(1).describe("Recipient email address string. Multiple recipients are comma separated."),
+  Cc: z.string().describe("Cc recipient email address string.").optional(),
+  Bcc: z.string().describe("Bcc recipient email address string.").optional(),
+  Tag: z.string().describe("Email tag used for categorization and analytics.").optional(),
+  ReplyTo: z.string().describe("Reply-To email address override.").optional(),
+  Headers: z.array(z.strictObject({
+    Name: z.string().min(1).describe("Custom header name.").optional(),
+    Value: z.string().describe("Custom header value.").optional()
+  })).describe("Custom headers to include on the email.").optional(),
+  TrackOpens: z.boolean().describe("Whether open tracking is enabled.").optional(),
+  TrackLinks: z.enum(["None", "HtmlAndText", "HtmlOnly", "TextOnly"]).describe("Link tracking mode recognized by the official Postmark API.").optional(),
+  Attachments: z.array(z.strictObject({
+    Name: z.string().min(1).describe("Attachment file name."),
+    Content: z.string().min(1).describe("Base64-encoded attachment content."),
+    ContentType: z.string().min(1).describe("Attachment MIME type."),
+    ContentID: z.string().min(1).describe("Optional content ID for inline attachments.").optional()
+  })).describe("Attachments to include on the email.").optional(),
+  Metadata: z.record(z.string(), z.string().describe("Metadata value.")).describe("Custom metadata key-value pairs attached to the message.").optional(),
+  MessageStream: z.string().describe("Message stream ID to use when sending the email.").optional(),
+  Subject: z.string().min(1).describe("Email subject line."),
+  HtmlBody: z.string().describe("HTML body content of the email.").optional(),
+  TextBody: z.string().describe("Plain-text body content of the email.").optional()
+});
+var sendEmailOutput = z.looseObject({}).describe("Postmark message submission result.");
+var sendEmailWithTemplateInput = z.strictObject({
+  TemplateId: z.int().min(1).describe("Template ID to use when rendering this message.").optional(),
+  TemplateAlias: z.string().min(1).describe("Template alias to use when rendering this message.").optional(),
+  TemplateModel: z.looseObject({}).describe("Additional upstream fields returned by Postmark."),
+  InlineCss: z.boolean().describe("Whether CSS blocks should be inlined into rendered HTML content.").optional(),
+  From: z.string().min(1).describe("Sender email address or full formatted sender string accepted by Postmark."),
+  To: z.string().min(1).describe("Recipient email address string. Multiple recipients are comma separated."),
+  Cc: z.string().describe("Cc recipient email address string.").optional(),
+  Bcc: z.string().describe("Bcc recipient email address string.").optional(),
+  Tag: z.string().describe("Email tag used for categorization and analytics.").optional(),
+  ReplyTo: z.string().describe("Reply-To email address override.").optional(),
+  Headers: z.array(z.strictObject({
+    Name: z.string().min(1).describe("Custom header name.").optional(),
+    Value: z.string().describe("Custom header value.").optional()
+  })).describe("Custom headers to include on the email.").optional(),
+  TrackOpens: z.boolean().describe("Whether open tracking is enabled.").optional(),
+  TrackLinks: z.enum(["None", "HtmlAndText", "HtmlOnly", "TextOnly"]).describe("Link tracking mode recognized by the official Postmark API.").optional(),
+  Attachments: z.array(z.strictObject({
+    Name: z.string().min(1).describe("Attachment file name."),
+    Content: z.string().min(1).describe("Base64-encoded attachment content."),
+    ContentType: z.string().min(1).describe("Attachment MIME type."),
+    ContentID: z.string().min(1).describe("Optional content ID for inline attachments.").optional()
+  })).describe("Attachments to include on the email.").optional(),
+  Metadata: z.record(z.string(), z.string().describe("Metadata value.")).describe("Custom metadata key-value pairs attached to the message.").optional(),
+  MessageStream: z.string().describe("Message stream ID to use when sending the email.").optional()
+});
+var sendEmailWithTemplateOutput = z.looseObject({}).describe("Postmark message submission result.");
+var sendBatchWithTemplatesInput = z.strictObject({
+  Messages: z.array(z.strictObject({
+    TemplateId: z.int().min(1).describe("Template ID to use when rendering this message.").optional(),
+    TemplateAlias: z.string().min(1).describe("Template alias to use when rendering this message.").optional(),
+    TemplateModel: z.looseObject({}).describe("Additional upstream fields returned by Postmark."),
+    InlineCss: z.boolean().describe("Whether CSS blocks should be inlined into rendered HTML content.").optional(),
+    From: z.string().min(1).describe("Sender email address or full formatted sender string accepted by Postmark."),
+    To: z.string().min(1).describe("Recipient email address string. Multiple recipients are comma separated."),
+    Cc: z.string().describe("Cc recipient email address string.").optional(),
+    Bcc: z.string().describe("Bcc recipient email address string.").optional(),
+    Tag: z.string().describe("Email tag used for categorization and analytics.").optional(),
+    ReplyTo: z.string().describe("Reply-To email address override.").optional(),
+    Headers: z.array(z.strictObject({
+      Name: z.string().min(1).describe("Custom header name.").optional(),
+      Value: z.string().describe("Custom header value.").optional()
+    })).describe("Custom headers to include on the email.").optional(),
+    TrackOpens: z.boolean().describe("Whether open tracking is enabled.").optional(),
+    TrackLinks: z.enum(["None", "HtmlAndText", "HtmlOnly", "TextOnly"]).describe("Link tracking mode recognized by the official Postmark API.").optional(),
+    Attachments: z.array(z.strictObject({
+      Name: z.string().min(1).describe("Attachment file name."),
+      Content: z.string().min(1).describe("Base64-encoded attachment content."),
+      ContentType: z.string().min(1).describe("Attachment MIME type."),
+      ContentID: z.string().min(1).describe("Optional content ID for inline attachments.").optional()
+    })).describe("Attachments to include on the email.").optional(),
+    Metadata: z.record(z.string(), z.string().describe("Metadata value.")).describe("Custom metadata key-value pairs attached to the message.").optional(),
+    MessageStream: z.string().describe("Message stream ID to use when sending the email.").optional()
+  })).min(1).max(500).describe("Templated messages to send in this batch request.").optional()
+});
+var sendBatchWithTemplatesOutput = z.array(z.looseObject({}).describe("Postmark message submission result.")).describe("Per-message results returned by Postmark batch template sending.");
+var searchOutboundMessagesInput = z.strictObject({
+  count: z.int().min(1).max(500).describe("Number of results to return per request.").optional(),
+  offset: z.int().min(0).describe("Number of results to skip before returning the current page.").optional(),
+  recipient: z.string().describe("Filter by the user who was receiving the email.").optional(),
+  fromemail: z.string().describe("Filter by the sender email address.").optional(),
+  tag: z.string().describe("Filter by message tag.").optional(),
+  status: z.enum(["queued", "sent", "processed"]).describe("Outbound message status filter accepted by Postmark search.").optional(),
+  todate: z.string().describe("Filter messages up to this datetime, inclusive.").optional(),
+  fromdate: z.string().describe("Filter messages starting from this datetime, inclusive.").optional(),
+  subject: z.string().describe("Filter by email subject.").optional(),
+  messagestream: z.string().describe("Filter by message stream ID.").optional(),
+  metadata: z.record(z.string(), z.string().describe("Metadata value.")).describe("Metadata filters mapped to Postmark metadata_<key> query parameters for outbound search.").optional()
+});
+var searchOutboundMessagesOutput = z.strictObject({
+  TotalCount: z.int().describe("Total number of messages that matched the search.").optional(),
+  Messages: z.array(z.looseObject({}).describe("Additional upstream fields returned by Postmark.")).describe("Outbound messages returned by the search.").optional()
+});
+var getOutboundMessageDetailsInput = z.strictObject({
+  messageId: z.string().min(1).describe("Outbound message ID returned by Postmark.").optional()
+});
+var getOutboundMessageDetailsOutput = z.looseObject({}).describe("Additional upstream fields returned by Postmark.");
+var getBouncesInput = z.strictObject({
+  count: z.int().min(1).max(500).describe("Number of results to return per request.").optional(),
+  offset: z.int().min(0).describe("Number of results to skip before returning the current page.").optional(),
+  type: z.string().describe("Filter by bounce type.").optional(),
+  inactive: z.boolean().describe("Whether to return only inactive bounces.").optional(),
+  emailFilter: z.string().describe("Filter by bounced email address.").optional(),
+  messageID: z.string().describe("Filter by outbound message ID.").optional(),
+  mailboxHash: z.string().describe("Filter by the mailbox hash portion of the address.").optional(),
+  tag: z.string().describe("Filter by tag.").optional(),
+  todate: z.string().describe("Only include bounces before this datetime.").optional(),
+  fromdate: z.string().describe("Only include bounces after this datetime.").optional()
+});
+var getBouncesOutput = z.strictObject({
+  TotalCount: z.int().describe("Total number of bounces that matched the filter.").optional(),
+  Bounces: z.array(z.looseObject({}).describe("Additional upstream fields returned by Postmark.")).describe("Bounces returned by Postmark.").optional()
+});
+var listTemplatesInput = z.strictObject({
+  count: z.int().min(1).max(500).describe("Number of results to return per request.").optional(),
+  offset: z.int().min(0).describe("Number of results to skip before returning the current page.").optional(),
+  TemplateType: z.enum(["Standard", "Layout"]).describe("Template type recognized by the official Postmark API.").optional(),
+  LayoutTemplate: z.string().describe("Filter by layout template alias.").optional()
+});
+var listTemplatesOutput = z.strictObject({
+  TotalCount: z.int().describe("Total number of templates.").optional(),
+  Templates: z.array(z.looseObject({}).describe("Additional upstream fields returned by Postmark.")).describe("Templates returned by Postmark.").optional()
+});
+var getTemplateInput = z.strictObject({
+  templateIdOrAlias: z.union([z.int().min(1).describe("Template ID."), z.string().min(1).describe("Template alias.")]).describe("Template ID or template alias accepted by the Postmark path parameter.").optional()
+});
+var getTemplateOutput = z.looseObject({}).describe("Additional upstream fields returned by Postmark.");
+var createTemplateInput = z.strictObject({
+  Name: z.string().min(1).describe("Template name."),
+  Subject: z.string().describe("Subject content for the template. Required for standard templates.").optional(),
+  HtmlBody: z.string().describe("HTML body content of the template.").optional(),
+  TextBody: z.string().describe("Plain-text body content of the template.").optional(),
+  TemplateType: z.enum(["Standard", "Layout"]).describe("Template type recognized by the official Postmark API.").optional(),
+  Alias: z.string().describe("Optional alias that identifies the template within the server.").optional(),
+  LayoutTemplate: z.string().describe("Optional layout template alias used by a standard template.").optional()
+});
+var createTemplateOutput = z.looseObject({}).describe("Additional upstream fields returned by Postmark.");
+var editTemplateInput = z.strictObject({
+  templateIdOrAlias: z.union([z.int().min(1).describe("Template ID."), z.string().min(1).describe("Template alias.")]).describe("Template ID or template alias accepted by the Postmark path parameter."),
+  Name: z.string().min(1).describe("Updated template name."),
+  Subject: z.string().describe("Updated template subject content when the template is standard.").optional(),
+  HtmlBody: z.string().describe("Updated HTML body content.").optional(),
+  TextBody: z.string().describe("Updated plain-text body content.").optional(),
+  Alias: z.string().describe("Updated alias that identifies the template within the server.").optional(),
+  LayoutTemplate: z.string().describe("Updated layout template alias for a standard template.").optional()
+});
+var editTemplateOutput = z.looseObject({}).describe("Additional upstream fields returned by Postmark.");
+var validateTemplateInput = z.strictObject({
+  Subject: z.string().describe("Subject content to validate against Postmark template syntax.").optional(),
+  HtmlBody: z.string().describe("HTML body content to validate.").optional(),
+  TextBody: z.string().describe("Plain-text body content to validate.").optional(),
+  TestRenderModel: z.looseObject({}).describe("Additional upstream fields returned by Postmark."),
+  InlineCssForHtmlTestRender: z.boolean().describe("Whether CSS blocks should be inlined when rendering HTML test output.").optional(),
+  TemplateType: z.enum(["Standard", "Layout"]).describe("Template type recognized by the official Postmark API.").optional(),
+  LayoutTemplate: z.string().describe("Optional layout template alias used while validating a standard template.").optional()
+});
+var validateTemplateOutput = z.looseObject({}).describe("Additional upstream fields returned by Postmark.");
+var postmarkActions = {
+  get_server: {
+    description: "Get the current Postmark server configuration for the connected server token.",
+    effect: "read",
+    inputSchema: getServerInput,
+    outputSchema: z.toJSONSchema(getServerOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_email: {
+    description: "Send a transactional email through the current Postmark server.",
+    effect: "write",
+    inputSchema: sendEmailInput,
+    outputSchema: z.toJSONSchema(sendEmailOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_email_with_template: {
+    description: "Send a single templated email through the current Postmark server.",
+    effect: "write",
+    inputSchema: sendEmailWithTemplateInput,
+    outputSchema: z.toJSONSchema(sendEmailWithTemplateOutput, { io: "output", unrepresentable: "any" })
+  },
+  send_batch_with_templates: {
+    description: "Send up to 500 templated emails in a single Postmark batch request.",
+    effect: "write",
+    inputSchema: sendBatchWithTemplatesInput,
+    outputSchema: z.toJSONSchema(sendBatchWithTemplatesOutput, { io: "output", unrepresentable: "any" })
+  },
+  search_outbound_messages: {
+    description: "Search outbound Postmark messages with filters and pagination.",
+    effect: "read",
+    inputSchema: searchOutboundMessagesInput,
+    outputSchema: z.toJSONSchema(searchOutboundMessagesOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_outbound_message_details: {
+    description: "Get detailed content and events for one outbound Postmark message.",
+    effect: "read",
+    inputSchema: getOutboundMessageDetailsInput,
+    outputSchema: z.toJSONSchema(getOutboundMessageDetailsOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_bounces: {
+    description: "Get Postmark bounces for the current server with optional filters.",
+    effect: "read",
+    inputSchema: getBouncesInput,
+    outputSchema: z.toJSONSchema(getBouncesOutput, { io: "output", unrepresentable: "any" })
+  },
+  list_templates: {
+    description: "List Postmark templates for the current server.",
+    effect: "read",
+    inputSchema: listTemplatesInput,
+    outputSchema: z.toJSONSchema(listTemplatesOutput, { io: "output", unrepresentable: "any" })
+  },
+  get_template: {
+    description: "Get one Postmark template by template ID or alias.",
+    effect: "read",
+    inputSchema: getTemplateInput,
+    outputSchema: z.toJSONSchema(getTemplateOutput, { io: "output", unrepresentable: "any" })
+  },
+  create_template: {
+    description: "Create a Postmark template.",
+    effect: "write",
+    inputSchema: createTemplateInput,
+    outputSchema: z.toJSONSchema(createTemplateOutput, { io: "output", unrepresentable: "any" })
+  },
+  edit_template: {
+    description: "Edit an existing Postmark template.",
+    effect: "write",
+    inputSchema: editTemplateInput,
+    outputSchema: z.toJSONSchema(editTemplateOutput, { io: "output", unrepresentable: "any" })
+  },
+  validate_template: {
+    description: "Validate Postmark template content and render test output.",
+    effect: "write",
+    inputSchema: validateTemplateInput,
+    outputSchema: z.toJSONSchema(validateTemplateOutput, { io: "output", unrepresentable: "any" })
+  }
+};
+
+// ../plugins/src/postmark/index.ts
+function createPostmarkPlugin() {
+  return createProviderPlugin({
+    description: "Postmark",
+    credentialProbe: "get_server",
+    actions: postmarkActions,
+    handlers: {
+      get_server: getServer,
+      send_email: sendEmail,
+      send_email_with_template: sendEmailWithTemplate,
+      send_batch_with_templates: sendBatchWithTemplates,
+      search_outbound_messages: searchOutboundMessages,
+      get_outbound_message_details: getOutboundMessageDetails,
+      get_bounces: getBounces,
+      list_templates: listTemplates,
+      get_template: getTemplate,
+      create_template: createTemplate,
+      edit_template: editTemplate,
+      validate_template: validateTemplate
+    }
+  });
+}
+var postmark_default = createPostmarkPlugin();
+export {
+  createPostmarkPlugin,
+  postmark_default as default
+};

package/dist/{prerender-MENYM2TY.js → prerender-2W7UT4SC.js}

@@ -1,6 +1,6 @@
 import {
   createProviderHttpClient
-} from "./chunk-E6JCVKW6.js";
+} from "./chunk-BNMLA2RC.js";
 import {
   asJsonObject,
   trimmedText
@@ -9,12 +9,12 @@ import {
   createProviderPlugin,
   requireApiKey,
   upstreamError
-} from "./chunk-ATK45BXV.js";
-import "./chunk-U7B6DS2O.js";
+} from "./chunk-X7ZUTKHR.js";
+import "./chunk-7ISGFRC6.js";
+import "./chunk-UY6ANCOY.js";
 import {
-  TBError,
-  external_exports
-} from "./chunk-UZM2RXZH.js";
+  TBError
+} from "./chunk-HA4BGL6C.js";
 import "./chunk-U67V476Y.js";
 
 // ../plugins/src/prerender/api.ts
@@ -87,57 +87,58 @@ async function getCacheClearStatus(_input, ctx) {
 }
 
 // ../plugins/src/prerender/schema.ts
-var recacheUrlsInput = external_exports.strictObject({
-  urls: external_exports.array(external_exports.url().describe("One public URL to cache or recache.")).min(1).describe("The public URLs to cache or recache."),
-  adaptiveType: external_exports.enum(["mobile", "desktop"]).describe("The Prerender adaptive cache type to target.").optional()
+import { z } from "zod/v4";
+var recacheUrlsInput = z.strictObject({
+  urls: z.array(z.url().describe("One public URL to cache or recache.")).min(1).describe("The public URLs to cache or recache."),
+  adaptiveType: z.enum(["mobile", "desktop"]).describe("The Prerender adaptive cache type to target.").optional()
 }).describe("The input payload for queueing one or more Prerender recache URLs.");
-var recacheUrlsOutput = external_exports.strictObject({
-  accepted: external_exports.boolean().describe("Whether Prerender accepted the request.").optional(),
-  raw: external_exports.unknown().describe("The raw Prerender response payload when one was returned.").nullable().optional()
+var recacheUrlsOutput = z.strictObject({
+  accepted: z.boolean().describe("Whether Prerender accepted the request.").optional(),
+  raw: z.unknown().describe("The raw Prerender response payload when one was returned.").nullable().optional()
 }).describe("The normalized result for a successful Prerender write request.");
-var addSitemapInput = external_exports.strictObject({
-  url: external_exports.url().describe("The sitemap XML URL to submit to Prerender.").optional()
+var addSitemapInput = z.strictObject({
+  url: z.url().describe("The sitemap XML URL to submit to Prerender.").optional()
 }).describe("The input payload for submitting a sitemap to Prerender.");
-var addSitemapOutput = external_exports.strictObject({
-  accepted: external_exports.boolean().describe("Whether Prerender accepted the request.").optional(),
-  raw: external_exports.unknown().describe("The raw Prerender response payload when one was returned.").nullable().optional()
+var addSitemapOutput = z.strictObject({
+  accepted: z.boolean().describe("Whether Prerender accepted the request.").optional(),
+  raw: z.unknown().describe("The raw Prerender response payload when one was returned.").nullable().optional()
 }).describe("The normalized result for a successful Prerender write request.");
-var clearCacheInput = external_exports.strictObject({
-  query: external_exports.string().min(1).regex(new RegExp("\\S")).describe("The wildcard query used to match cached URLs to clear, such as https://example.com%.").optional()
+var clearCacheInput = z.strictObject({
+  query: z.string().min(1).regex(new RegExp("\\S")).describe("The wildcard query used to match cached URLs to clear, such as https://example.com%.").optional()
 }).describe("The input payload for queueing a Prerender cache clear request.");
-var clearCacheOutput = external_exports.strictObject({
-  status: external_exports.enum(["queued", "in_progress"]).describe("The cache clear job state reported by Prerender.").optional(),
-  raw: external_exports.unknown().describe("The raw Prerender response payload when one was returned.").nullable().optional()
+var clearCacheOutput = z.strictObject({
+  status: z.enum(["queued", "in_progress"]).describe("The cache clear job state reported by Prerender.").optional(),
+  raw: z.unknown().describe("The raw Prerender response payload when one was returned.").nullable().optional()
 }).describe("The normalized result returned by the Prerender cache clear API.");
-var getCacheClearStatusInput = external_exports.strictObject({}).describe("This action does not require any input parameters.");
-var getCacheClearStatusOutput = external_exports.strictObject({
-  status: external_exports.enum(["idle", "in_progress"]).describe("The current cache clear job state reported by Prerender.").optional(),
-  raw: external_exports.unknown().describe("The raw Prerender response payload when one was returned.").nullable().optional()
+var getCacheClearStatusInput = z.strictObject({}).describe("This action does not require any input parameters.");
+var getCacheClearStatusOutput = z.strictObject({
+  status: z.enum(["idle", "in_progress"]).describe("The current cache clear job state reported by Prerender.").optional(),
+  raw: z.unknown().describe("The raw Prerender response payload when one was returned.").nullable().optional()
 }).describe("The normalized Prerender cache clear status response.");
 var prerenderActions = {
   recache_urls: {
     description: "Queue one or more URLs for first-time caching or recaching with the Prerender recache API.",
     effect: "write",
     inputSchema: recacheUrlsInput,
-    outputSchema: external_exports.toJSONSchema(recacheUrlsOutput, { io: "output", unrepresentable: "any" })
+    outputSchema: z.toJSONSchema(recacheUrlsOutput, { io: "output", unrepresentable: "any" })
   },
   add_sitemap: {
     description: "Submit a sitemap XML URL to Prerender so it can discover and cache new URLs from that sitemap.",
     effect: "write",
     inputSchema: addSitemapInput,
-    outputSchema: external_exports.toJSONSchema(addSitemapOutput, { io: "output", unrepresentable: "any" })
+    outputSchema: z.toJSONSchema(addSitemapOutput, { io: "output", unrepresentable: "any" })
   },
   clear_cache: {
     description: "Queue a Prerender cache clear request for URLs matching a wildcard query pattern.",
     effect: "write",
     inputSchema: clearCacheInput,
-    outputSchema: external_exports.toJSONSchema(clearCacheOutput, { io: "output", unrepresentable: "any" })
+    outputSchema: z.toJSONSchema(clearCacheOutput, { io: "output", unrepresentable: "any" })
   },
   get_cache_clear_status: {
     description: "Check whether a Prerender cache clear job is currently running for the authenticated account.",
     effect: "read",
     inputSchema: getCacheClearStatusInput,
-    outputSchema: external_exports.toJSONSchema(getCacheClearStatusOutput, { io: "output", unrepresentable: "any" })
+    outputSchema: z.toJSONSchema(getCacheClearStatusOutput, { io: "output", unrepresentable: "any" })
   }
 };