runline 0.33.0 → 0.35.0

package/dist/plugins/adalo/src/index.js

@@ -1,36 +1,22 @@
-async function apiRequest(appId, apiKey, method, path, body, qs) {
-    const url = new URL(`https://api.adalo.com/v0/apps/${appId}${path}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const opts = {
+import { credentialJson, pathSegment } from "../../_shared/credentials.js";
+import { adaloCredential } from "./credentials.js";
+/** A path beneath the connection's app, signed through the credential. */
+function apiRequest(ctx, method, path, body, query) {
+    const appId = pathSegment(ctx.connection.config.appId);
+    return credentialJson(ctx, adaloCredential, "adalo", {
+        target: "api",
+        path: `${appId}/${path}`,
         method,
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Bearer ${apiKey}`,
-        },
-    };
-    if (body && Object.keys(body).length > 0) {
-        opts.body = JSON.stringify(body);
-    }
-    const res = await fetch(url.toString(), opts);
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`Adalo API error ${res.status}: ${text}`);
-    }
-    if (res.status === 204)
-        return { success: true };
-    return res.json();
+        query,
+        ...(body && Object.keys(body).length > 0 ? { json: body } : {}),
+    });
 }
-async function paginate(appId, apiKey, collectionId, limit) {
+async function paginate(ctx, collectionId, limit) {
     const results = [];
     let offset = 0;
     const pageSize = 100;
     while (true) {
-        const data = (await apiRequest(appId, apiKey, "GET", `/collections/${collectionId}`, undefined, {
+        const data = (await apiRequest(ctx, "GET", `collections/${pathSegment(collectionId)}`, undefined, {
             limit: pageSize,
             offset,
         }));
@@ -44,15 +30,10 @@ async function paginate(appId, apiKey, collectionId, limit) {
     }
     return results;
 }
-function getConn(ctx) {
-    return {
-        appId: ctx.connection.config.appId,
-        apiKey: ctx.connection.config.apiKey,
-    };
-}
 export default function adalo(rl) {
     rl.setName("adalo");
     rl.setVersion("0.1.0");
+    rl.setCredential(adaloCredential);
     rl.setConnectionSchema({
         appId: {
             type: "string",
@@ -84,8 +65,7 @@ export default function adalo(rl) {
         },
         async execute(input, ctx) {
             const { collectionId, fields } = input;
-            const { appId, apiKey } = getConn(ctx);
-            return apiRequest(appId, apiKey, "POST", `/collections/${collectionId}`, fields);
+            return apiRequest(ctx, "POST", `collections/${pathSegment(collectionId)}`, fields);
         },
     });
     rl.registerAction("collection.get", {
@@ -101,8 +81,7 @@ export default function adalo(rl) {
         },
         async execute(input, ctx) {
             const { collectionId, rowId } = input;
-            const { appId, apiKey } = getConn(ctx);
-            return apiRequest(appId, apiKey, "GET", `/collections/${collectionId}/${rowId}`);
+            return apiRequest(ctx, "GET", `collections/${pathSegment(collectionId)}/${pathSegment(rowId)}`);
         },
     });
     rl.registerAction("collection.list", {
@@ -122,8 +101,7 @@ export default function adalo(rl) {
         },
         async execute(input, ctx) {
             const { collectionId, limit } = input;
-            const { appId, apiKey } = getConn(ctx);
-            return paginate(appId, apiKey, collectionId, limit);
+            return paginate(ctx, collectionId, limit);
         },
     });
     rl.registerAction("collection.update", {
@@ -144,8 +122,7 @@ export default function adalo(rl) {
         },
         async execute(input, ctx) {
             const { collectionId, rowId, fields } = input;
-            const { appId, apiKey } = getConn(ctx);
-            return apiRequest(appId, apiKey, "PUT", `/collections/${collectionId}/${rowId}`, fields);
+            return apiRequest(ctx, "PUT", `collections/${pathSegment(collectionId)}/${pathSegment(rowId)}`, fields);
         },
     });
     rl.registerAction("collection.delete", {
@@ -161,8 +138,7 @@ export default function adalo(rl) {
         },
         async execute(input, ctx) {
             const { collectionId, rowId } = input;
-            const { appId, apiKey } = getConn(ctx);
-            return apiRequest(appId, apiKey, "DELETE", `/collections/${collectionId}/${rowId}`);
+            return apiRequest(ctx, "DELETE", `collections/${pathSegment(collectionId)}/${pathSegment(rowId)}`);
         },
     });
 }

package/dist/plugins/affinity/src/credentials.js

@@ -0,0 +1,19 @@
+import { staticCredential } from "../../_shared/credentials.js";
+/** An API key as the Basic password, with an empty username, to Affinity's one origin. */
+export const affinityCredential = staticCredential({
+    id: "affinity",
+    auth: { kind: "basic" },
+    local: { username: { value: "" }, password: "apiKey" },
+    targets: {
+        api: {
+            baseUrl: "https://api.affinity.co/",
+            methods: ["GET", "POST", "PUT", "DELETE"],
+        },
+    },
+    probe: {
+        target: "api",
+        path: "auth/whoami",
+        method: "GET",
+        acceptedStatuses: [200],
+    },
+});

package/dist/plugins/affinity/src/index.js

@@ -1,39 +1,22 @@
-const BASE_URL = "https://api.affinity.co";
-async function apiRequest(apiKey, method, path, body, qs) {
-    const url = new URL(`${BASE_URL}${path}`);
-    if (qs) {
-        for (const [k, v] of Object.entries(qs)) {
-            if (v !== undefined)
-                url.searchParams.set(k, String(v));
-        }
-    }
-    const opts = {
+import { credentialJson, pathSegment } from "../../_shared/credentials.js";
+import { affinityCredential } from "./credentials.js";
+function apiRequest(ctx, method, path, body, qs) {
+    return credentialJson(ctx, affinityCredential, "affinity", {
+        target: "api",
+        path,
         method,
-        headers: {
-            "Content-Type": "application/json",
-            Authorization: `Basic ${btoa(`:${apiKey}`)}`,
-        },
-    };
-    if (body && Object.keys(body).length > 0) {
-        opts.body = JSON.stringify(body);
-    }
-    const res = await fetch(url.toString(), opts);
-    if (!res.ok) {
-        const text = await res.text();
-        throw new Error(`Affinity API error ${res.status}: ${text}`);
-    }
-    if (res.status === 204)
-        return { success: true };
-    return res.json();
+        query: qs,
+        ...(body && Object.keys(body).length > 0 ? { json: body } : {}),
+    });
 }
-async function paginateAll(apiKey, path, dataKey, limit) {
+async function paginateAll(ctx, path, dataKey, limit, extraQuery) {
     const results = [];
     let pageToken;
     while (true) {
-        const qs = { page_size: 500 };
+        const qs = { ...extraQuery, page_size: 500 };
         if (pageToken)
             qs.page_token = pageToken;
-        const data = (await apiRequest(apiKey, "GET", path, undefined, qs));
+        const data = (await apiRequest(ctx, "GET", path, undefined, qs));
         const items = data[dataKey] ?? [];
         results.push(...items);
         if (limit && results.length >= limit)
@@ -44,12 +27,10 @@ async function paginateAll(apiKey, path, dataKey, limit) {
     }
     return results;
 }
-function getKey(ctx) {
-    return ctx.connection.config.apiKey;
-}
 export default function affinity(rl) {
     rl.setName("affinity");
     rl.setVersion("0.1.0");
+    rl.setCredential(affinityCredential);
     rl.setConnectionSchema({
         apiKey: {
             type: "string",
@@ -67,7 +48,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { listId } = input;
-            return apiRequest(getKey(ctx), "GET", `/lists/${listId}`);
+            return apiRequest(ctx, "GET", `lists/${pathSegment(listId)}`);
         },
     });
     rl.registerAction("list.list", {
@@ -82,7 +63,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { limit } = input ?? {};
-            const data = (await apiRequest(getKey(ctx), "GET", "/lists"));
+            const data = (await apiRequest(ctx, "GET", "lists"));
             if (limit)
                 return data.slice(0, limit);
             return data;
@@ -102,7 +83,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { listId, entityId, ...rest } = input;
-            return apiRequest(getKey(ctx), "POST", `/lists/${listId}/list-entries`, {
+            return apiRequest(ctx, "POST", `lists/${pathSegment(listId)}/list-entries`, {
                 entity_id: entityId,
                 ...rest,
             });
@@ -121,7 +102,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { listId, listEntryId } = input;
-            return apiRequest(getKey(ctx), "GET", `/lists/${listId}/list-entries/${listEntryId}`);
+            return apiRequest(ctx, "GET", `lists/${pathSegment(listId)}/list-entries/${pathSegment(listEntryId)}`);
         },
     });
     rl.registerAction("listEntry.list", {
@@ -137,7 +118,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { listId, limit } = input;
-            return paginateAll(getKey(ctx), `/lists/${listId}/list-entries`, "list_entries", limit);
+            return paginateAll(ctx, `lists/${pathSegment(listId)}/list-entries`, "list_entries", limit);
         },
     });
     rl.registerAction("listEntry.delete", {
@@ -153,7 +134,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { listId, listEntryId } = input;
-            return apiRequest(getKey(ctx), "DELETE", `/lists/${listId}/list-entries/${listEntryId}`);
+            return apiRequest(ctx, "DELETE", `lists/${pathSegment(listId)}/list-entries/${pathSegment(listEntryId)}`);
         },
     });
     // ── Person ──────────────────────────────────────────
@@ -183,7 +164,7 @@ export default function affinity(rl) {
             };
             if (organizationIds)
                 body.organization_ids = organizationIds;
-            return apiRequest(getKey(ctx), "POST", "/persons", body);
+            return apiRequest(ctx, "POST", "persons", body);
         },
     });
     rl.registerAction("person.get", {
@@ -194,7 +175,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { personId } = input;
-            return apiRequest(getKey(ctx), "GET", `/persons/${personId}`);
+            return apiRequest(ctx, "GET", `persons/${pathSegment(personId)}`);
         },
     });
     rl.registerAction("person.list", {
@@ -210,10 +191,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { term, limit } = input ?? {};
-            const qs = {};
-            if (term)
-                qs.term = term;
-            return paginateAll(getKey(ctx), "/persons", "persons", limit);
+            return paginateAll(ctx, "persons", "persons", limit, term ? { term } : undefined);
         },
     });
     rl.registerAction("person.update", {
@@ -243,7 +221,7 @@ export default function affinity(rl) {
                 body.last_name = lastName;
             if (organizationIds)
                 body.organization_ids = organizationIds;
-            return apiRequest(getKey(ctx), "PUT", `/persons/${personId}`, body);
+            return apiRequest(ctx, "PUT", `persons/${pathSegment(personId)}`, body);
         },
     });
     rl.registerAction("person.delete", {
@@ -254,7 +232,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { personId } = input;
-            return apiRequest(getKey(ctx), "DELETE", `/persons/${personId}`);
+            return apiRequest(ctx, "DELETE", `persons/${pathSegment(personId)}`);
         },
     });
     // ── Organization ────────────────────────────────────
@@ -283,7 +261,7 @@ export default function affinity(rl) {
             const body = { name, domain };
             if (personIds)
                 body.person_ids = personIds;
-            return apiRequest(getKey(ctx), "POST", "/organizations", body);
+            return apiRequest(ctx, "POST", "organizations", body);
         },
     });
     rl.registerAction("organization.get", {
@@ -298,7 +276,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { organizationId } = input;
-            return apiRequest(getKey(ctx), "GET", `/organizations/${organizationId}`);
+            return apiRequest(ctx, "GET", `organizations/${pathSegment(organizationId)}`);
         },
     });
     rl.registerAction("organization.list", {
@@ -314,10 +292,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { term, limit } = input ?? {};
-            const qs = {};
-            if (term)
-                qs.term = term;
-            return paginateAll(getKey(ctx), "/organizations", "organizations", limit);
+            return paginateAll(ctx, "organizations", "organizations", limit, term ? { term } : undefined);
         },
     });
     rl.registerAction("organization.update", {
@@ -354,7 +329,7 @@ export default function affinity(rl) {
                 body.domain = domain;
             if (personIds)
                 body.person_ids = personIds;
-            return apiRequest(getKey(ctx), "PUT", `/organizations/${organizationId}`, body);
+            return apiRequest(ctx, "PUT", `organizations/${pathSegment(organizationId)}`, body);
         },
     });
     rl.registerAction("organization.delete", {
@@ -369,7 +344,7 @@ export default function affinity(rl) {
         },
         async execute(input, ctx) {
             const { organizationId } = input;
-            return apiRequest(getKey(ctx), "DELETE", `/organizations/${organizationId}`);
+            return apiRequest(ctx, "DELETE", `organizations/${pathSegment(organizationId)}`);
         },
     });
 }

package/dist/plugins/agentMail/src/credentials.js

@@ -0,0 +1,35 @@
+import { configChoice, staticCredential } from "../../_shared/credentials.js";
+const REGIONS = ["us", "eu"];
+const ORIGINS = {
+    us: "https://api.agentmail.to/v0/",
+    eu: "https://api.agentmail.eu/v0/",
+};
+/**
+ * An AgentMail API key, sent as a bearer to the region's one API origin.
+ * Sends get their own `send` target: AgentMail deduplicates sends (and only
+ * sends) by `Idempotency-Key`, so that is where the contract is declared and
+ * the transport sets the header. Inbox and draft creation deduplicate by the
+ * body's `client_id` instead and stay on `api`.
+ */
+export const agentMailCredential = staticCredential({
+    id: "agentMail",
+    auth: { kind: "bearer" },
+    local: { secret: "apiKey" },
+    targets: (config) => {
+        const baseUrl = ORIGINS[configChoice(config.region, REGIONS, "us")];
+        return {
+            api: { baseUrl, methods: ["GET", "POST", "PATCH", "DELETE"] },
+            send: {
+                baseUrl,
+                methods: ["POST"],
+                idempotency: { header: "Idempotency-Key", methods: ["POST"] },
+            },
+        };
+    },
+    probe: {
+        target: "api",
+        path: "auth/me",
+        method: "GET",
+        acceptedStatuses: [200],
+    },
+});

package/dist/plugins/agentMail/src/drafts.js

@@ -0,0 +1,137 @@
+import * as t from "typebox";
+import { atLeastOne, attachments, clientId, contentFields, draftFields, id, idList, inboxFields, labelFields, listFields, STRICT, sendFields, strings, timestamp, } from "./schemas.js";
+import { attachmentPath, draftPath, inboxPath, request, sendMessage, } from "./shared.js";
+const list = t.Object({ ...inboxFields, ...listFields }, STRICT);
+const draft = t.Object(draftFields, STRICT);
+const attachment = t.Object({ ...draftFields, attachmentId: id }, STRICT);
+const create = t.Object({
+    ...inboxFields,
+    ...contentFields,
+    to: t.Optional(strings),
+    cc: t.Optional(strings),
+    bcc: t.Optional(strings),
+    replyTo: t.Optional(strings),
+    subject: t.Optional(t.String()),
+    labels: t.Optional(strings),
+    inReplyTo: t.Optional(id),
+    forwardOf: t.Optional(id),
+    replyAll: t.Optional(t.Boolean()),
+    sendAt: t.Optional(timestamp),
+    clientId: t.Optional(clientId),
+}, {
+    ...STRICT,
+    allOf: [
+        // A draft replies or forwards, never both.
+        { not: { required: ["inReplyTo", "forwardOf"] } },
+        // replyAll: true derives every recipient from the message it replies to.
+        {
+            anyOf: [
+                {
+                    not: {
+                        required: ["replyAll"],
+                        properties: { replyAll: { const: true } },
+                    },
+                },
+                {
+                    required: ["inReplyTo"],
+                    not: {
+                        anyOf: [
+                            { required: ["to"] },
+                            { required: ["cc"] },
+                            { required: ["bcc"] },
+                        ],
+                    },
+                },
+            ],
+        },
+    ],
+});
+const nullable = (schema) => t.Optional(t.Union([schema, t.Null()]));
+const changes = {
+    ...labelFields,
+    to: nullable(strings),
+    cc: nullable(strings),
+    bcc: nullable(strings),
+    replyTo: nullable(strings),
+    subject: nullable(t.String()),
+    text: nullable(t.String()),
+    html: nullable(t.String()),
+    sendAt: nullable(timestamp),
+    addAttachments: t.Optional(attachments),
+    removeAttachments: t.Optional(idList),
+};
+const update = t.Object({ ...draftFields, ...changes }, { ...STRICT, ...atLeastOne(changes) });
+const send = t.Object({ ...draftFields, ...labelFields, ...sendFields }, STRICT);
+export function registerDraftActions(rl) {
+    rl.registerAction("draft.list", {
+        access: "read",
+        description: "List one page of inbox drafts, preserving next_page_token. Includes optional label and timestamp filters.",
+        inputSchema: list,
+        execute: (input, ctx) => {
+            const { inboxId, ...query } = input;
+            return request(ctx, `${inboxPath(inboxId)}/drafts`, { query });
+        },
+    });
+    rl.registerAction("draft.get", {
+        access: "read",
+        description: "Get a draft for review before sending.",
+        inputSchema: draft,
+        execute: (input, ctx) => {
+            const p = input;
+            return request(ctx, draftPath(p.inboxId, p.draftId));
+        },
+    });
+    rl.registerAction("draft.create", {
+        access: "write",
+        description: "Create a draft for review, or schedule automatic delivery with sendAt. Empty drafts are valid. inReplyTo and forwardOf are mutually exclusive; replyAll requires inReplyTo and no recipient overrides. Use clientId for retry-safe creation.",
+        inputSchema: create,
+        execute: (input, ctx) => {
+            const { inboxId, ...body } = input;
+            return request(ctx, `${inboxPath(inboxId)}/drafts`, {
+                method: "POST",
+                body,
+            });
+        },
+    });
+    rl.registerAction("draft.update", {
+        access: "write",
+        description: "Edit a draft without changing its kind. Omitted fields stay unchanged; null or [] clears recipients. sendAt schedules/reschedules automatic delivery; null cancels scheduling. Attachments use addAttachments/removeAttachments.",
+        inputSchema: update,
+        execute: (input, ctx) => {
+            const { inboxId, draftId, ...body } = input;
+            return request(ctx, draftPath(inboxId, draftId), {
+                method: "PATCH",
+                body,
+            });
+        },
+    });
+    rl.registerAction("draft.delete", {
+        access: "write",
+        description: "Delete a draft rather than sending it.",
+        inputSchema: draft,
+        execute: (input, ctx) => {
+            const p = input;
+            return request(ctx, draftPath(p.inboxId, p.draftId), {
+                method: "DELETE",
+            });
+        },
+    });
+    rl.registerAction("draft.send", {
+        access: "write",
+        description: "Send an existing draft now. Returns message_id and thread_id. No automatic retries; supply idempotencyKey for retries of the identical send within 24 hours.",
+        inputSchema: send,
+        execute: (input, ctx) => {
+            const { inboxId, draftId, idempotencyKey, ...body } = input;
+            return sendMessage(ctx, `${draftPath(inboxId, draftId)}/send`, body, idempotencyKey);
+        },
+    });
+    rl.registerAction("draft.attachment", {
+        access: "read",
+        description: "Get draft attachment metadata and a temporary download_url (plus text_url when text was extracted), without fetching them. Treat the URLs as private.",
+        inputSchema: attachment,
+        execute: (input, ctx) => {
+            const p = input;
+            return request(ctx, attachmentPath(draftPath(p.inboxId, p.draftId), p.attachmentId));
+        },
+    });
+}

package/dist/plugins/agentMail/src/inboxes.js

@@ -0,0 +1,95 @@
+import * as t from "typebox";
+import { atLeastOne, clientId, id, inboxFields, pageFields, STRICT, } from "./schemas.js";
+import { inboxPath, request } from "./shared.js";
+const metadataValue = t.Union([
+    t.String({ maxLength: 256 }),
+    t.Number(),
+    t.Boolean(),
+]);
+const metadataKey = t.String({ maxLength: 256 });
+const metadataOptions = { maxProperties: 256, propertyNames: metadataKey };
+const status = t.Union([t.Literal("active"), t.Literal("paused")], {
+    description: "paused stops sending and receiving: sends fail with 403 inbox_paused and incoming mail is neither delivered nor bounced, then or on resume. Stored mail, drafts and API keys are kept; set active to resume.",
+});
+const list = t.Object({ ...pageFields, ascending: t.Optional(t.Boolean()) }, STRICT);
+const search = t.Object({
+    ...pageFields,
+    query: t.String({
+        ...id,
+        description: "Words matching the start of words in the address or display name (sup matches support@…, port does not). An exact address ranks first.",
+    }),
+}, STRICT);
+const inbox = t.Object(inboxFields, STRICT);
+const create = t.Object({
+    username: t.Optional(id),
+    domain: t.Optional(t.String({
+        ...id,
+        description: "Verified custom domain; defaults to agentmail.to.",
+    })),
+    displayName: t.Optional(t.String()),
+    status: t.Optional(status),
+    clientId: t.Optional(clientId),
+    metadata: t.Optional(t.Record(t.String(), metadataValue, metadataOptions)),
+}, STRICT);
+const changes = {
+    displayName: t.Optional(t.String()),
+    status: t.Optional(status),
+    metadata: t.Optional(t.Union([
+        t.Record(t.String(), t.Union([metadataValue, t.Null()]), {
+            ...metadataOptions,
+            minProperties: 1,
+        }),
+        t.Null(),
+    ], {
+        description: "Merge keys; null values delete keys, metadata: null clears all. Omitted keys stay unchanged.",
+    })),
+};
+const update = t.Object({ ...inboxFields, ...changes }, { ...STRICT, ...atLeastOne(changes) });
+export function registerInboxActions(rl) {
+    rl.registerAction("inbox.list", {
+        access: "read",
+        description: "List one page of inboxes. Preserves next_page_token; pass it as pageToken for the next page.",
+        inputSchema: list,
+        execute: (input, ctx) => request(ctx, "inboxes", { query: input }),
+    });
+    rl.registerAction("inbox.search", {
+        access: "read",
+        description: "Search inboxes by address or display name, ranked by relevance. A page can be empty and still carry next_page_token; keep paging until it is absent.",
+        inputSchema: search,
+        execute: (input, ctx) => request(ctx, "inboxes/search", {
+            query: input,
+        }),
+    });
+    rl.registerAction("inbox.get", {
+        access: "read",
+        description: "Get an inbox: its email address, status and metadata.",
+        inputSchema: inbox,
+        execute: (input, ctx) => request(ctx, inboxPath(input.inboxId)),
+    });
+    rl.registerAction("inbox.create", {
+        access: "write",
+        description: "Create an email inbox. Omit username for a random address; use clientId to avoid duplicates when retrying.",
+        inputSchema: create,
+        execute: (input, ctx) => request(ctx, "inboxes", {
+            method: "POST",
+            body: input,
+        }),
+    });
+    rl.registerAction("inbox.update", {
+        access: "write",
+        description: "Update display name, pause or resume (status), or merge metadata. Requires at least one change; metadata supports explicit null clearing.",
+        inputSchema: update,
+        execute: (input, ctx) => {
+            const { inboxId, ...body } = input;
+            return request(ctx, inboxPath(inboxId), { method: "PATCH", body });
+        },
+    });
+    rl.registerAction("inbox.delete", {
+        access: "write",
+        description: "Delete an inbox. Destructive; confirm the inbox ID before calling. To stop mail without deleting, set status to paused with inbox.update.",
+        inputSchema: inbox,
+        execute: (input, ctx) => request(ctx, inboxPath(input.inboxId), {
+            method: "DELETE",
+        }),
+    });
+}

package/dist/plugins/agentMail/src/index.js

@@ -0,0 +1,35 @@
+import * as t from "typebox";
+import { agentMailCredential } from "./credentials.js";
+import { registerDraftActions } from "./drafts.js";
+import { registerInboxActions } from "./inboxes.js";
+import { registerMessageActions } from "./messages.js";
+import { STRICT } from "./schemas.js";
+import { request } from "./shared.js";
+import { registerThreadActions } from "./threads.js";
+export default function agentMail(rl) {
+    rl.setName("agentMail");
+    rl.setVersion("0.1.0");
+    rl.setCredential(agentMailCredential);
+    rl.setConnectionSchema(t.Object({
+        apiKey: t.String({
+            minLength: 1,
+            env: "AGENTMAIL_API_KEY",
+            description: "AgentMail API key with permissions for the requested inboxes and operations. https://console.agentmail.to",
+        }),
+        region: t.Optional(t.String({
+            env: "AGENTMAIL_REGION",
+            default: "us",
+            description: "us (api.agentmail.to, default) or eu (api.agentmail.eu). Any other value is refused rather than sent to the default host.",
+        })),
+    }));
+    rl.registerAction("whoami", {
+        access: "read",
+        description: "Read the authenticated AgentMail identity and API-key scope.",
+        inputSchema: t.Object({}, STRICT),
+        execute: (_input, ctx) => request(ctx, "auth/me"),
+    });
+    registerInboxActions(rl);
+    registerMessageActions(rl);
+    registerThreadActions(rl);
+    registerDraftActions(rl);
+}