@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/notion_mcp/executors.js

@@ -1,9 +1,9 @@
 import { ProtocolError, SdkHttpError, UnauthorizedError } from "@modelcontextprotocol/client";
 import { compactObject, looseArray, optionalBoolean, optionalInteger, optionalNumber, optionalRawString, optionalRecord, optionalString, optionalStringArray, requiredRawString, } from "../../core/cast.js";
 import { withMcpClient } from "../mcp-client.js";
-import { defineOAuthProviderExecutors, mapProviderActionSources, providerResponseError, providerUserAgent, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { defineOAuthProviderExecutors, mapProviderActionSources, providerInputError, providerResponseError, providerUserAgent, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
 import { notionMcpEndpoint } from "./endpoints.js";
-import { decodeNotionToolText, parseNotionComments, parseNotionPage, parseNotionSearch, parseNotionSelf, parseNotionToolAccess, } from "./mcp-response.js";
+import { decodeNotionToolText, parseNotionComments, parseNotionCreatedComment, parseNotionCreatedPages, parseNotionPage, parseNotionSearch, parseNotionSelf, parseNotionToolAccess, parseNotionUpdatedPage, } from "./mcp-response.js";
 const service = "notion_mcp";
 const selfUserId = "self";
 const toolsByAction = {
@@ -36,7 +36,45 @@ const toolsByAction = {
         arguments: () => ({}),
         parse: (value) => ({ tools: parseNotionToolAccess(value) }),
     },
+    create_pages: {
+        tool: "notion-create-pages",
+        arguments: (input) => {
+            const pages = looseArray(input.pages);
+            if (pages.length === 0)
+                throw providerInputError("pages is required.");
+            return { ...compactObject(input), pages };
+        },
+        parse: (value) => ({ ...parseNotionCreatedPages(value) }),
+    },
+    update_page: {
+        tool: "notion-update-page",
+        arguments: (input) => ({
+            ...compactObject(input),
+            page_id: requiredInputString(input.page_id, "page_id"),
+            command: requiredInputString(input.command, "command"),
+        }),
+        parse: (value, input) => ({
+            page_id: requiredInputString(input.page_id, "page_id"),
+            ...parseNotionUpdatedPage(value),
+        }),
+    },
+    create_comment: {
+        tool: "notion-create-comment",
+        arguments: (input) => ({
+            ...compactObject(input),
+            page_id: requiredInputString(input.page_id, "page_id"),
+            markdown: requiredInputString(input.markdown, "markdown"),
+        }),
+        parse: (value) => compactObject({ comment: parseNotionCreatedComment(value) }),
+    },
 };
+/**
+ * The actions that change the workspace. Sign-in requires every read tool and
+ * none of these: a workspace whose owner withheld the writes from the
+ * connection, or an older server, may not list them, and a credential must
+ * not be refused for a tool it would never call.
+ */
+const writeActions = new Set(["create_pages", "update_page", "create_comment"]);
 const handlers = mapProviderActionSources(service, toolsByAction, (_actionName, source) => async (input, context) => {
     const result = await callNotionTool(context, source.tool, source.arguments(input));
     return { ...source.parse(result.value, input), raw: result.raw };
@@ -45,14 +83,15 @@ export const executors = defineOAuthProviderExecutors(service, handlers, {
     skipDnsValidation: true,
 });
 export const credentialValidators = {
-    /** Require every tool the actions map, then identify the user so the account key is the Notion user ID. */
+    /** Require the baseline read tools, then identify the user by the Notion user ID. */
     async oauth2(input, { fetcher, signal }) {
         const context = { accessToken: input.accessToken, fetcher, signal };
-        const { toolCount, self } = await withNotionMcpClient(context, "validate", async (client, signal) => {
+        const { toolCount, self } = await withNotionMcpClient(context, async (client, signal) => {
             const tools = await listNotionTools(client, signal);
             const available = new Set(tools.map((tool) => tool.name));
-            const missing = Object.values(toolsByAction)
-                .map((source) => source.tool)
+            const missing = Object.entries(toolsByAction)
+                .filter(([action]) => !writeActions.has(action))
+                .map(([, source]) => source.tool)
                 .filter((tool) => !available.has(tool));
             if (missing.length > 0) {
                 throw new ProviderRequestError(502, `Notion MCP did not expose the tools this connector needs: ${[...new Set(missing)].join(", ")}.`);
@@ -107,7 +146,7 @@ async function listNotionTools(client, signal) {
     return tools;
 }
 async function callNotionTool(context, name, input) {
-    const result = await withNotionMcpClient(context, "execute", (client, signal) => client.callTool({ name, arguments: input }, { signal }));
+    const result = await withNotionMcpClient(context, (client, signal) => client.callTool({ name, arguments: input }, { signal }));
     return readNotionToolResult(name, result);
 }
 /** The text blocks joined are the raw answer; structured content, when the server sends it, is the value. */
@@ -138,7 +177,7 @@ function notionToolError(name, record) {
     }
     return new ProviderRequestError(502, `Notion MCP tool ${name} failed.`, record);
 }
-function withNotionMcpClient(context, phase, run) {
+function withNotionMcpClient(context, run) {
     return runProviderRequest({ signal: context.signal, label: "Notion MCP" }, (signal) => withMcpClient({
         endpoint: new URL(notionMcpEndpoint),
         transport: "streamable_http",
@@ -146,31 +185,21 @@ function withNotionMcpClient(context, phase, run) {
         headers: { authorization: `Bearer ${context.accessToken}`, "user-agent": providerUserAgent },
         redirect: "manual",
         signal,
-        mapError: (error) => mapNotionMcpError(error, phase),
+        mapError: mapNotionMcpError,
     }, (client) => run(client, signal)));
 }
-/**
- * Sign-in reports a rejected token as invalid input (400); a run reports it as an expired authorization (401).
- * Anything unrecognized is left to runProviderRequest, which tells a timeout (504) from a failure (502).
- */
-function mapNotionMcpError(error, phase) {
+// Status alone does not establish that reconnecting can resolve a provider failure.
+function mapNotionMcpError(error) {
     if (error instanceof ProviderRequestError)
         return error;
-    const credentialStatus = phase === "validate" ? 400 : 401;
     if (error instanceof UnauthorizedError) {
-        return new ProviderRequestError(credentialStatus, "Notion MCP credential is invalid or expired.");
+        return new ProviderRequestError(401, "Notion MCP authorization request failed.", undefined, "provider_error");
     }
     if (error instanceof SdkHttpError) {
-        const status = error.status;
-        if (status === 401 || status === 403) {
-            return new ProviderRequestError(credentialStatus, "Notion MCP credential is invalid or expired.");
-        }
-        // The SDK error carries the response body; only the status is reported so a token echoed in it never is.
-        const providerStatus = 400 <= status && status < 500 ? status : 502;
-        return new ProviderRequestError(providerStatus, `Notion MCP request failed with HTTP ${status}.`);
+        return new ProviderRequestError(error.status, `Notion MCP request failed with HTTP ${error.status}.`, undefined, error.status === 429 ? "rate_limited" : "provider_error");
     }
     if (error instanceof ProtocolError) {
-        return new ProviderRequestError(502, `Notion MCP request failed: ${error.message}`);
+        return new ProviderRequestError(502, `Notion MCP protocol error ${error.code}.`, undefined, "provider_error");
     }
     return error;
 }

package/src/providers/notion_mcp/mcp-response.d.ts

@@ -50,6 +50,11 @@ interface NotionMcpToolAccess {
     landing_page_url: string | undefined;
     landing_page_action: string | undefined;
 }
+interface NotionMcpCreatedPage {
+    id?: string;
+    url?: string;
+    title?: string;
+}
 /** Notion's tools answer JSON in a text block on most calls and prose or XML fragments on the rest. */
 export declare function decodeNotionToolText(text: string): unknown;
 /**
@@ -83,4 +88,25 @@ export declare function parseNotionComments(value: unknown): NotionMcpComment[];
  * reason it is unavailable. The reason is kept as text and never interpreted.
  */
 export declare function parseNotionToolAccess(value: unknown): NotionMcpToolAccess[];
+/**
+ * The pages a notion-create-pages answer names, in its order: a `pages`/`results` list of `{id, url, title}`
+ * records, a single page record, or the page links in a prose answer, each id read off its link. An async task's
+ * id travels beside them when the server deferred the work.
+ */
+export declare function parseNotionCreatedPages(value: unknown): {
+    pages: NotionMcpCreatedPage[];
+    async_task_id?: string;
+};
+/** The page a notion-update-page answer names: its link, when the prose or the record carries one, and a deferred task's id. */
+interface NotionMcpUpdatedPage {
+    url?: string;
+    async_task_id?: string;
+    warnings?: Record<string, unknown>[];
+}
+export declare function parseNotionUpdatedPage(value: unknown): NotionMcpUpdatedPage;
+/** The comment a notion-create-comment answer names: the comment record itself, or the first of a listed shape. */
+export declare function parseNotionCreatedComment(value: unknown): {
+    id?: string;
+    discussion_id?: string;
+} | undefined;
 export {};

package/src/providers/notion_mcp/mcp-response.js

@@ -6,6 +6,9 @@ const contentOpening = /<content\b[^<>]*>/i;
 const tagAttribute = /(?<![\w:-])([\w:-]+)\s*=\s*"([^"]*)"/g;
 const anyTag = /<[^<>]+>/g;
 const namedEntities = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'" };
+// A Notion page link in prose, and the 32-hex page id a link or an id carries.
+const notionLink = /https:\/\/(?:www\.)?notion\.so\/[^\s)"'<>]+/g;
+const notionPageId = /([0-9a-f]{32})(?:[?#]|$)/i;
 /** Notion's tools answer JSON in a text block on most calls and prose or XML fragments on the rest. */
 export function decodeNotionToolText(text) {
     const trimmed = text.trim();
@@ -143,6 +146,98 @@ export function parseNotionToolAccess(value) {
         ];
     });
 }
+/**
+ * The pages a notion-create-pages answer names, in its order: a `pages`/`results` list of `{id, url, title}`
+ * records, a single page record, or the page links in a prose answer, each id read off its link. An async task's
+ * id travels beside them when the server deferred the work.
+ */
+export function parseNotionCreatedPages(value) {
+    const record = optionalRecord(value);
+    if (record?.object === "async_task") {
+        return { pages: [], ...compactObject({ async_task_id: asyncTaskId(record) }) };
+    }
+    const listed = findList(value, "pages", "results", "created_pages").flatMap((item) => {
+        const page = readCreatedPage(item);
+        return page ? [page] : [];
+    });
+    const single = listed.length === 0 ? readCreatedPage(record) : undefined;
+    const pages = listed.length > 0 ? listed : single ? [single] : linkedPages(optionalString(value) ?? textOf(record));
+    return { pages, ...compactObject({ async_task_id: asyncTaskId(record) }) };
+}
+export function parseNotionUpdatedPage(value) {
+    const record = optionalRecord(value);
+    const url = (record && pickOptionalString(record, "url")) ?? linkedPages(optionalString(value) ?? textOf(record))[0]?.url;
+    return compactObject({
+        url,
+        async_task_id: asyncTaskId(record),
+        warnings: Array.isArray(record?.warnings)
+            ? record.warnings.flatMap((value) => {
+                const warning = optionalRecord(value);
+                return warning ? [warning] : [];
+            })
+            : undefined,
+    });
+}
+/** The comment a notion-create-comment answer names: the comment record itself, or the first of a listed shape. */
+export function parseNotionCreatedComment(value) {
+    const record = optionalRecord(value);
+    const comment = record && (optionalRecord(record.comment) ?? record);
+    const typed = compactObject({
+        id: comment && pickOptionalString(comment, "id", "comment_id"),
+        discussion_id: comment && pickOptionalString(comment, "discussion_id"),
+    });
+    if (Object.keys(typed).length > 0)
+        return typed;
+    const listed = parseNotionComments(value)[0];
+    if (!listed)
+        return undefined;
+    const fromList = compactObject({
+        id: listed.id,
+        discussion_id: listed.discussion_id,
+    });
+    return Object.keys(fromList).length > 0 ? fromList : undefined;
+}
+function readCreatedPage(value) {
+    const record = optionalRecord(value);
+    if (!record)
+        return undefined;
+    const url = pickOptionalString(record, "url");
+    const page = compactObject({
+        id: pickOptionalString(record, "id", "page_id") ?? (url && pageIdOf(url)),
+        url,
+        title: readTitle(record),
+    });
+    return page.id !== undefined || page.url !== undefined ? page : undefined;
+}
+/** The page links a prose answer carries, each with the id its link ends in, in order and without repeats. */
+function linkedPages(text) {
+    if (!text)
+        return [];
+    const seen = new Set();
+    return [...text.matchAll(notionLink)].flatMap((match) => {
+        // A link at the end of a sentence carries its punctuation into the match.
+        const url = match[0].replace(/[.,;:!?]+$/, "");
+        if (seen.has(url))
+            return [];
+        seen.add(url);
+        return [compactObject({ id: pageIdOf(url), url })];
+    });
+}
+function pageIdOf(url) {
+    return notionPageId.exec(url)?.[1]?.toLowerCase();
+}
+/** The text a tool answered under any of its names, for an answer that was JSON with the prose inside it. */
+function textOf(record) {
+    return record ? pickOptionalString(record, "text", "message", "result") : undefined;
+}
+function asyncTaskId(record) {
+    if (!record)
+        return undefined;
+    if (record.object === "async_task")
+        return pickOptionalString(record, "id");
+    const task = optionalRecord(record.async_task) ?? optionalRecord(record.task);
+    return pickOptionalString(record, "async_task_id", "task_id") ?? (task && pickOptionalString(task, "id", "task_id"));
+}
 /** The first present list among keys of a decoded object, or the value itself when it is a list. */
 function findList(value, ...keys) {
     if (Array.isArray(value))

package/src/providers/omise/executors.js

@@ -114,7 +114,7 @@ async function request(path, context, method = "GET", form, query) {
     }
     if (!response.ok) {
         const record = optionalRecord(payload);
-        throw new ProviderRequestError(response.status, optionalString(record?.message) ?? `Omise request failed with status ${response.status}`, payload, optionalString(record?.code));
+        throw new ProviderRequestError(response.status, optionalString(record?.message) ?? `Omise request failed with status ${response.status}`, payload);
     }
     return payload;
 }

package/src/providers/outlook/executors.js

@@ -1,5 +1,5 @@
-import { compactObject, optionalString, requiredRecord } from "../../core/cast.js";
-import { defineOAuthProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, } from "../provider-runtime.js";
+import { compactObject, optionalString, requiredBoolean, requiredRecord } from "../../core/cast.js";
+import { defineOAuthProviderExecutors, defineProviderProxy, providerInputError, requiredInputString, ProviderRequestError, } from "../provider-runtime.js";
 import { microsoftGraphJson, microsoftGraphRequest } from "./microsoft-graph.js";
 import { outlookMessageReceived } from "./trigger-on-message-received.js";
 const outlookGraphBaseUrl = "https://graph.microsoft.com/v1.0";
@@ -22,6 +22,30 @@ const outlookActionHandlers = {
     get_message(input, deps) {
         return getMessage(input, deps);
     },
+    move_message(input, deps) {
+        return moveMessage(input, requiredInputString(input.destinationId, "destinationId"), deps);
+    },
+    archive_message(input, deps) {
+        return moveMessage(input, "archive", deps);
+    },
+    async delete_message(input, { accessToken, fetcher, signal }) {
+        await outlookRequest(`me/messages/${encodeURIComponent(requiredInputString(input.messageId, "messageId"))}`, {
+            accessToken,
+            fetcher,
+            signal,
+            method: "DELETE",
+        });
+        return { success: true };
+    },
+    set_message_read(input, { accessToken, fetcher, signal }) {
+        return outlookJsonRequest(`me/messages/${encodeURIComponent(requiredInputString(input.messageId, "messageId"))}`, {
+            accessToken,
+            fetcher,
+            signal,
+            method: "PATCH",
+            body: { isRead: requiredBoolean(input.isRead, "isRead", providerInputError) },
+        });
+    },
     create_draft(input, deps) {
         return createDraft(input, deps);
     },
@@ -229,6 +253,15 @@ async function getMessage(input, { accessToken, fetcher }) {
         headers,
     });
 }
+async function moveMessage(input, destinationId, { accessToken, fetcher, signal }) {
+    return outlookJsonRequest(`me/messages/${encodeURIComponent(requiredInputString(input.messageId, "messageId"))}/move`, {
+        accessToken,
+        fetcher,
+        signal,
+        method: "POST",
+        body: { destinationId },
+    });
+}
 async function createDraft(input, { accessToken, fetcher }) {
     return outlookJsonRequest("me/messages", {
         accessToken,

package/src/providers/porteden/actions.d.ts

@@ -0,0 +1,2 @@
+import type { ActionDefinition } from "../../core/types.ts";
+export declare const portedenActions: ActionDefinition[];

package/src/providers/porteden/actions.js

@@ -0,0 +1,162 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const emailId = s.nonEmptyString("Provider-prefixed email ID, such as google:abc123 or m365:xyz789.");
+const bodyType = s.stringEnum("Body content type; defaults to html.", ["html", "text"]);
+const participant = s.object("Email recipient.", {
+    email: s.nonEmptyString("Email address."),
+    name: s.string("Display name."),
+}, { optional: ["name"] });
+const recipients = s.array("Recipient addresses and optional display names.", participant, {
+    minItems: 1,
+});
+const email = s.looseObject("Email with permission-filtered fields and attachment metadata; additional fields are preserved.", {
+    id: s.string("Provider-prefixed email ID."),
+    threadId: s.nullable(s.string("Provider-prefixed thread ID.")),
+    subject: s.nullable(s.string("Email subject.")),
+    from: s.nullable(s.looseObject("Sender details.", {})),
+    to: s.nullable(s.array("Recipients.", s.looseObject("Recipient details.", {}))),
+    body: s.nullable(s.string("Email body when requested and permitted.")),
+    bodyPreview: s.nullable(s.string("Short body preview.")),
+    bodyType: s.nullable(s.string("Body content type.")),
+    receivedAt: s.nullable(s.string("Receipt timestamp in UTC.")),
+    isRead: s.boolean("Whether the email is read."),
+    hasAttachments: s.boolean("Whether attachments exist."),
+    attachments: s.nullable(s.array("Attachment metadata; no file content is downloaded.", s.looseObject("Attachment details.", {}))),
+    labels: s.nullable(s.stringArray("Labels or categories.")),
+    provider: s.string("Source provider, such as GOOGLE or M365."),
+    emailAccountOwner: s.nullable(s.string("Mailbox owner address.")),
+});
+const sent = s.looseObject("Send result; Microsoft 365 can return null message and thread IDs.", {
+    success: s.boolean("Whether the operation succeeded."),
+    emailId: s.nullable(s.string("Provider-prefixed sent email ID, when available.")),
+    threadId: s.nullable(s.string("Provider-prefixed thread ID, when available.")),
+    errorMessage: s.nullable(s.string("Upstream failure details, when available.")),
+});
+const success = s.requiredObject("Successful operation result.", {
+    success: s.boolean("Whether the operation succeeded."),
+});
+export const portedenActions = [
+    defineProviderAction("porteden", {
+        name: "search_emails",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Search emails across connected Gmail and Microsoft 365 accounts. Email access and search_emails permission must be enabled in PortEden; pass nextPageToken as pageToken to continue.",
+        inputSchema: s.object("Email search filters and pagination.", {
+            q: s.string("Free-text search query."),
+            from: s.string("Filter by sender email address."),
+            to: s.string("Filter by recipient email address."),
+            subject: s.string("Partial subject filter."),
+            label: s.string("Label or category filter."),
+            unread: s.boolean("Filter by read status; true selects unread emails."),
+            after: s.string("Emails received after this UTC timestamp.", { format: "date-time" }),
+            before: s.string("Emails received before this UTC timestamp.", { format: "date-time" }),
+            hasAttachment: s.boolean("Filter by attachment presence."),
+            limit: s.integer("Maximum results; defaults to 20, at most 50.", {
+                minimum: 1,
+                maximum: 50,
+            }),
+            includeBody: s.boolean("Include full bodies; defaults to false."),
+            pageToken: s.string("Opaque nextPageToken from the previous result."),
+        }, { required: [] }),
+        outputSchema: s.looseObject("Merged email search results sorted newest first.", {
+            emails: s.array("Matching emails.", email),
+            totalCount: s.integer("Total matching count reported by PortEden."),
+            hasMore: s.boolean("Whether more results are available."),
+            nextPageToken: s.nullable(s.string("Opaque continuation token.")),
+            accessInfo: s.unknown("Active access restrictions, if present."),
+            authWarnings: s.unknown("Upstream account authentication warnings, if present."),
+        }),
+    }),
+    defineProviderAction("porteden", {
+        name: "get_email",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a provider-prefixed email, including its body by default, subject to PortEden view_email permissions.",
+        inputSchema: s.object("Email lookup.", { emailId, includeBody: s.boolean("Include full body; defaults to true.") }, { optional: ["includeBody"] }),
+        outputSchema: email,
+    }),
+    defineProviderAction("porteden", {
+        name: "get_thread",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Read a complete email thread in chronological order with body content, subject to PortEden view_thread permissions.",
+        inputSchema: s.requiredObject("Thread lookup.", {
+            threadId: s.nonEmptyString("Provider-prefixed thread ID, such as google:abc123 or m365:xyz789."),
+        }),
+        outputSchema: s.looseObject("Email thread.", {
+            id: s.string("Provider-prefixed thread ID."),
+            subject: s.nullable(s.string("Thread subject.")),
+            messages: s.array("Messages in chronological order.", email),
+            messageCount: s.integer("Message count."),
+            participants: s.array("Thread participants.", s.looseObject("Participant details.", {})),
+            lastMessageAt: s.nullable(s.string("Most recent message timestamp.")),
+            provider: s.string("Source provider."),
+        }),
+    }),
+    defineProviderAction("porteden", {
+        name: "send_email",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Send an email through a connected account with PortEden send_email permission. Choose sendFrom or connectionId when needed; the default account is otherwise used.",
+        inputSchema: s.object("New email.", {
+            to: recipients,
+            cc: s.array("Recipient addresses and optional display names.", participant),
+            bcc: s.array("Recipient addresses and optional display names.", participant),
+            subject: s.string("Email subject."),
+            body: s.string("Email body content."),
+            bodyType,
+            importance: s.stringEnum("Priority; defaults to normal.", ["low", "normal", "high"]),
+            sendFrom: s.nonEmptyString("Connected account email address to send from."),
+            connectionId: s.integer("Provider connection ID to send from."),
+        }, { optional: ["cc", "bcc", "bodyType", "importance", "sendFrom", "connectionId"] }),
+        outputSchema: sent,
+    }),
+    defineProviderAction("porteden", {
+        name: "reply_email",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Reply to an email, preserving its thread, with PortEden reply_to_email permission.",
+        inputSchema: s.object("Email reply.", {
+            emailId,
+            body: s.string("Reply body content."),
+            bodyType,
+            replyAll: s.boolean("Reply to all original recipients except the sending account; defaults to false."),
+        }, { optional: ["bodyType", "replyAll"] }),
+        outputSchema: sent,
+    }),
+    defineProviderAction("porteden", {
+        name: "forward_email",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Forward an email to recipients with PortEden forward_email permission.",
+        inputSchema: s.object("Email forwarding options.", {
+            emailId,
+            to: recipients,
+            cc: s.array("Recipient addresses and optional display names.", participant),
+            body: s.string("Optional message to prepend."),
+            bodyType,
+        }, { optional: ["cc", "body", "bodyType"] }),
+        outputSchema: sent,
+    }),
+    defineProviderAction("porteden", {
+        name: "modify_email",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Change read status or labels/categories. PortEden requires mark_as_read and/or apply_labels permission for the requested changes.",
+        inputSchema: s.requireAnyProperty(s.object("Email property changes.", {
+            emailId,
+            markAsRead: s.boolean("Mark as read (true) or unread (false)."),
+            addLabels: s.stringArray("Labels or categories to add."),
+            removeLabels: s.stringArray("Labels or categories to remove."),
+        }, { optional: ["markAsRead", "addLabels", "removeLabels"] }), ["markAsRead", "addLabels", "removeLabels"]),
+        outputSchema: success,
+    }),
+    defineProviderAction("porteden", {
+        name: "delete_email",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Move an email to Trash or Deleted Items with PortEden delete_email permission. This is a recoverable soft delete.",
+        inputSchema: s.requiredObject("Email to move to trash.", { emailId }),
+        outputSchema: success,
+    }),
+];

package/src/providers/porteden/executors.d.ts

@@ -0,0 +1,4 @@
+import type { CredentialValidators, ProviderExecutors, ProviderProxyExecutor } from "../../core/types.ts";
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;
+export declare const proxy: ProviderProxyExecutor;

package/src/providers/porteden/executors.js

@@ -0,0 +1,140 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { requiredInputString, requiredResponseRecord, ProviderRequestError, runProviderRequest, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { portedenActions } from "./actions.js";
+const baseUrl = "https://api.porteden.com";
+const defaultHeaders = { accept: "application/json" };
+async function request({ route, method, data, apiKey, fetcher, parentSignal }) {
+    try {
+        return await runProviderRequest({ signal: parentSignal, label: "PortEden" }, async (signal) => {
+            const url = new URL(`${baseUrl}${route}`);
+            if (method === "GET") {
+                for (const [key, value] of Object.entries(data)) {
+                    if (value != null)
+                        url.searchParams.set(key, String(value));
+                }
+            }
+            const hasBody = method === "POST" || method === "PATCH";
+            const headers = new Headers(defaultHeaders);
+            headers.set("Authorization", `Bearer ${apiKey}`);
+            if (hasBody)
+                headers.set("content-type", "application/json");
+            const response = await fetcher(url.toString(), {
+                method,
+                headers,
+                body: hasBody ? JSON.stringify(data) : undefined,
+                signal,
+            });
+            if (response.status === 204 && (method === "PATCH" || method === "DELETE"))
+                return { success: true };
+            const text = await response.text();
+            let payload;
+            try {
+                payload = JSON.parse(text);
+            }
+            catch {
+                payload = undefined;
+            }
+            const body = optionalRecord(payload);
+            if (!response.ok || body?.success === false) {
+                const detail = [
+                    optionalRawString(body?.code),
+                    optionalRawString(body?.error),
+                    optionalRawString(body?.message),
+                    optionalRawString(body?.errorMessage),
+                ]
+                    .filter(Boolean)
+                    .join(": ") || `HTTP ${response.status}`;
+                throw new ProviderRequestError(response.ok ? 502 : response.status, `PortEden request failed: ${detail}`, undefined, body?.error === "API authentication failed"
+                    ? "authorization_failed"
+                    : response.status === 429
+                        ? "rate_limited"
+                        : "provider_error");
+            }
+            return requiredResponseRecord(payload, "PortEden response");
+        });
+    }
+    catch (error) {
+        if (error instanceof ProviderRequestError)
+            error.message = error.message.split(apiKey).join("[REDACTED]");
+        throw error;
+    }
+}
+const handlers = mapProviderActionHandlers("porteden", portedenActions, (action) => async (dataInput, context) => {
+    const { emailId, threadId, ...data } = dataInput;
+    let route = "/api/access/email/messages";
+    let method = "GET";
+    switch (action.name) {
+        case "get_email":
+            route += `/${encodeURIComponent(String(emailId))}`;
+            break;
+        case "get_thread":
+            route = `/api/access/email/threads/${encodeURIComponent(String(threadId))}`;
+            break;
+        case "send_email":
+            route += "/send";
+            method = "POST";
+            break;
+        case "reply_email":
+            route += `/${encodeURIComponent(String(emailId))}/reply`;
+            method = "POST";
+            break;
+        case "forward_email":
+            route += `/${encodeURIComponent(String(emailId))}/forward`;
+            method = "POST";
+            break;
+        case "modify_email":
+            route += `/${encodeURIComponent(String(emailId))}`;
+            method = "PATCH";
+            break;
+        case "delete_email":
+            route += `/${encodeURIComponent(String(emailId))}`;
+            method = "DELETE";
+            break;
+    }
+    return request({
+        route: route,
+        method: method,
+        data: data,
+        apiKey: context.apiKey,
+        fetcher: context.fetcher,
+        parentSignal: context.signal,
+    });
+});
+export const executors = defineApiKeyProviderExecutors("porteden", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const body = await request({
+            route: "/api/auth/token/status",
+            method: "GET",
+            data: {},
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher: fetcher,
+            parentSignal: signal,
+        });
+        if (body.authenticated !== true)
+            throw new ProviderRequestError(400, "PortEden token is not authenticated", undefined, "invalid_input");
+        return {
+            profile: {
+                displayName: optionalRawString(body.operatorName) || optionalRawString(body.userName) || "PortEden API Key",
+            },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "porteden",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json" }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, "Provider request failed"), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+});