@oomol-lab/open-connector 1.8.0 → 1.9.0

package/src/providers/oomol_console/runtime.js

@@ -1,7 +1,7 @@
 import { optionalNumber, optionalRawString } from "../../core/cast.js";
 import { randomUUIDv7 } from "../../core/uuid-v7.js";
 import { ProviderRequestError } from "../provider-runtime.js";
-import { parseConnectionPermissionGroups, replacePermissionGroupMembers, serializeConnectionPermissionGroups, toPermissionGroupsView, } from "./permission-groups.js";
+import { effectiveTriggerPermission, parseConnectionPermissionGroups, replacePermissionGroupMembers, serializeConnectionPermissionGroups, toPermissionGroupsView, } from "./permission-groups.js";
 import { requestOomolConsole, requestOomolConsoleWithResponse } from "./request.js";
 const dayMs = 24 * 60 * 60 * 1000;
 const maxBalancePages = 100;
@@ -73,7 +73,6 @@ export async function executeOomolConsoleAction(actionName, input, context, fetc
         }
         case "list_team_connections": {
             const teamId = requireTeamId(context);
-            await requireTeamManager(teamId, apiKey, fetcher, deps.endpoints);
             return {
                 connections: await listTeamConnections(teamId, apiKey, fetcher, deps.endpoints),
             };
@@ -129,7 +128,7 @@ async function listTeamConnections(teamId, apiKey, fetcher, endpoints) {
     return asArray(await requestOomolConsole({
         endpoints,
         endpoint: "connector",
-        path: "/v1/connections",
+        path: "/v1/apps",
         apiKey,
         fetcher,
         teamId,
@@ -245,6 +244,9 @@ async function mutateConnectionPermissionGroups(actionName, input, context, apiK
     let affectedMemberIds;
     switch (actionName) {
         case "update_connection_default_permission_group":
+            state.defaultGroup.triggerPermission ??= effectiveTriggerPermission(state.defaultGroup);
+            if (input.triggerPermission !== undefined)
+                state.defaultGroup.triggerPermission = await parseTriggerPermissionInput(input.triggerPermission, loaded.connection.service, apiKey, fetcher, endpoints);
             state.defaultGroup.actionPermission = parseActionPermissionInput(input.actionPermission, loaded.availableActions);
             break;
         case "create_connection_permission_group": {
@@ -253,6 +255,9 @@ async function mutateConnectionPermissionGroups(actionName, input, context, apiK
             const memberIds = parseMemberIdsInput(input.memberIds, loaded.members);
             state.groups.push({
                 groupId,
+                triggerPermission: input.triggerPermission === undefined
+                    ? { mode: "none" }
+                    : await parseTriggerPermissionInput(input.triggerPermission, loaded.connection.service, apiKey, fetcher, endpoints),
                 name: requireString(input.name, "name"),
                 memberIds,
                 actionPermission: parseActionPermissionInput(input.actionPermission, loaded.availableActions),
@@ -269,6 +274,9 @@ async function mutateConnectionPermissionGroups(actionName, input, context, apiK
             updatedSourceGroupId = groupId;
             const memberIds = parseMemberIdsInput(input.memberIds, loaded.members);
             group.name = requireString(input.name, "name");
+            if (input.triggerPermission !== undefined)
+                group.triggerPermission = await parseTriggerPermissionInput(input.triggerPermission, loaded.connection.service, apiKey, fetcher, endpoints);
+            group.triggerPermission ??= effectiveTriggerPermission(group);
             group.actionPermission = parseActionPermissionInput(input.actionPermission, loaded.availableActions);
             state = replacePermissionGroupMembers(state, groupId, memberIds);
             break;
@@ -680,3 +688,21 @@ function compact(value) {
 function invalidResponse(message) {
     return new ProviderRequestError(502, `OOMOL Console response is invalid: ${message}`);
 }
+async function parseTriggerPermissionInput(value, service, apiKey, fetcher, endpoints) {
+    const permission = asRecord(value, "triggerPermission");
+    if (permission.mode === "all" || permission.mode === "none")
+        return { mode: permission.mode };
+    if (permission.mode !== "selected" || !Array.isArray(permission.triggerIds) || permission.triggerIds.length === 0)
+        throw new ProviderRequestError(400, "triggerPermission is invalid", undefined, "invalid_input");
+    const available = asArray(await requestOomolConsole({
+        endpoints,
+        endpoint: "connector",
+        path: `/v1/providers/${encodeURIComponent(service)}/trigger-permissions`,
+        apiKey,
+        fetcher,
+    }), "Trigger permissions").map((item) => asRecord(item, "Trigger permission").id);
+    const triggerIds = permission.triggerIds.map((id) => requireString(id, "triggerId"));
+    if (new Set(triggerIds).size !== triggerIds.length || triggerIds.some((id) => !available.includes(id)))
+        throw new ProviderRequestError(400, "Trigger cannot be selected for this Connection", undefined, "invalid_input");
+    return { mode: "selected", triggerIds: triggerIds.toSorted() };
+}

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

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

package/src/providers/opper/executors.js

@@ -0,0 +1,89 @@
+import { looseArray, optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderJsonBody, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const service = "opper";
+const apiBaseUrl = "https://api.opper.ai/v3/compat";
+const anthropicApiVersion = "2023-06-01";
+// Reasoning model completions may exceed the shared default request timeout.
+const inferenceTimeoutMs = 300_000;
+const handlers = {
+    create_chat_completion(input, context) {
+        if (input.stream === true) {
+            throw providerInputError("stream=true is not supported by connector actions");
+        }
+        return requestOpper({ path: "/chat/completions", body: input }, context);
+    },
+    create_message(input, context) {
+        if (input.stream === true) {
+            throw providerInputError("stream=true is not supported by connector actions");
+        }
+        return requestOpper({ path: "/v1/messages", body: input }, context);
+    },
+    list_models(_input, context) {
+        return requestOpper({ path: "/models" }, context);
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: apiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = await requestOpper({ path: "/models" }, { apiKey: input.apiKey, fetcher, signal });
+        return {
+            profile: { displayName: "Opper API Key" },
+            grantedScopes: [],
+            metadata: {
+                validationEndpoint: "/models",
+                availableModels: looseArray(payload.data)
+                    .map((model) => optionalString(optionalRecord(model)?.id))
+                    .filter((id) => id !== undefined),
+            },
+        };
+    },
+};
+function requestOpper(input, context) {
+    const headers = new Headers({
+        authorization: `Bearer ${context.apiKey}`,
+        "content-type": "application/json",
+        "user-agent": providerUserAgent,
+    });
+    // The Anthropic Messages-compatible endpoint takes the same header as Anthropic's API.
+    if (input.path === "/v1/messages") {
+        headers.set("anthropic-version", anthropicApiVersion);
+    }
+    return runProviderRequest({
+        signal: context.signal,
+        label: "Opper",
+        timeoutMs: input.body === undefined ? undefined : inferenceTimeoutMs,
+    }, async (signal) => {
+        const response = await context.fetcher(`${apiBaseUrl}${input.path}`, {
+            method: input.body === undefined ? "GET" : "POST",
+            headers,
+            body: input.body === undefined ? undefined : JSON.stringify(input.body),
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "Opper returned invalid JSON",
+            invalidJsonFallback: response.ok ? undefined : (text) => ({ message: text }),
+        });
+        if (!response.ok) {
+            const error = optionalRecord(payload);
+            const message = optionalString(optionalRecord(error?.error)?.message) ??
+                optionalString(error?.error) ??
+                optionalString(error?.message) ??
+                `Opper request failed with HTTP ${response.status}`;
+            throw new ProviderRequestError(response.status, message, payload, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        const result = requiredResponseRecord(payload, "Opper response");
+        if (input.path === "/models" && !Array.isArray(result.data)) {
+            throw providerResponseError("Opper returned a malformed model list");
+        }
+        return result;
+    });
+}

package/src/providers/outlook/executors.js

@@ -1,4 +1,4 @@
-import { compactObject, requiredRecord } from "../../core/cast.js";
+import { compactObject, optionalString, requiredRecord } from "../../core/cast.js";
 import { defineOAuthProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, } from "../provider-runtime.js";
 import { microsoftGraphJson, microsoftGraphRequest } from "./microsoft-graph.js";
 import { outlookMessageReceived } from "./trigger-on-message-received.js";
@@ -374,12 +374,12 @@ function buildMailboxSettingsPayload(input) {
         automaticRepliesSetting: input.automaticRepliesSetting && typeof input.automaticRepliesSetting === "object"
             ? buildAutomaticRepliesSettingPayload(asObject(input.automaticRepliesSetting))
             : undefined,
-        dateFormat: typeof input.dateFormat === "string" ? input.dateFormat : undefined,
+        dateFormat: optionalString(input.dateFormat),
         delegateMeetingMessageDeliveryOptions: typeof input.delegateMeetingMessageDeliveryOptions === "string"
             ? input.delegateMeetingMessageDeliveryOptions
             : undefined,
         language: input.language && typeof input.language === "object" ? buildLanguagePayload(asObject(input.language)) : undefined,
-        timeFormat: typeof input.timeFormat === "string" ? input.timeFormat : undefined,
+        timeFormat: optionalString(input.timeFormat),
         timeZone: typeof input.timeZone === "string" ? input.timeZone : undefined,
         workingHours: input.workingHours && typeof input.workingHours === "object"
             ? buildWorkingHoursPayload(asObject(input.workingHours))

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

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

package/src/providers/picky_assist/actions.js

@@ -0,0 +1,61 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const recipient = s.object("One recipient and optional personalized message or media.", {
+    number: s.string("Phone number with country code, without a leading zero, plus sign, or spaces.", {
+        pattern: "^[1-9][0-9]{4,}$",
+    }),
+    messenger_id: s.nonEmptyString("Facebook Messenger recipient ID; use with application 5 instead of number."),
+    message: s.string("Personalized text or image/video caption; falls back to globalmessage when empty."),
+    media: s.string("Public media URL for this recipient; supported by WhatsApp Official and Shared Numbers.", {
+        format: "uri",
+    }),
+    reference_number: s.string("Your reference returned in delivery webhooks; not an idempotency key."),
+    quoted: s.string("Message ID to quote in a reply on WhatsApp Web Automation."),
+}, { optional: ["number", "messenger_id", "message", "media", "reference_number", "quoted"] });
+export const pickyAssistActions = [
+    defineProviderAction("picky_assist", {
+        name: "get_balance",
+        operationType: "read",
+        description: "Get the Picky Assist account balance using the connected project API token.",
+        requiredScopes: [],
+        inputSchema: s.requiredObject("No input is required.", {}),
+        outputSchema: s.looseObject("Picky Assist account balance response.", {
+            status: s.integer("Provider business status; 100 indicates success."),
+            message: s.string("Provider status message."),
+            balance: s.number("Available account balance reported by Picky Assist."),
+        }),
+    }),
+    defineProviderAction("picky_assist", {
+        name: "send_messages",
+        operationType: "write",
+        description: "Submit text or public-URL media messages to one or more Picky Assist recipients. Success means accepted for processing, not delivered. WhatsApp session and channel restrictions still apply.",
+        requiredScopes: [],
+        inputSchema: s.object("Text or media messages for a connected channel.", {
+            application: s.integer("Channel ID from https://app.pickyassist.com/settings/channels; use 5 for Facebook Messenger."),
+            globalmessage: s.string("Shared text or image/video caption, used when a recipient message is empty."),
+            globalmedia: s.string("Public media URL fetched by Picky Assist, not by Connector. Media limits depend on the channel and file type.", { format: "uri" }),
+            media_name: s.string("Display filename for PDFs and documents; unsupported by Phone Automation.", {
+                maxLength: 20,
+            }),
+            priority: s.integer("Queue priority: 0 for low (default), 1 for high.", {
+                minimum: 0,
+                maximum: 1,
+            }),
+            createcontact: s.literal(1, { description: "Set to 1 to create contacts against the channel." }),
+            voice: s.literal(1, { description: "Set to 1 to send audio as a voice note on WhatsApp Web Automation." }),
+            data: s.array("Recipients with optional personalized content. Each needs text or media, either shared or individual.", recipient, { minItems: 1 }),
+        }, {
+            optional: ["globalmessage", "globalmedia", "media_name", "priority", "createcontact", "voice"],
+        }),
+        outputSchema: s.looseObject("Submission response; use delivery webhooks to determine final delivery.", {
+            status: s.integer("Provider business status; 100 indicates acceptance."),
+            message: s.string("Provider status message."),
+            push_id: s.string("Batch submission ID."),
+            data: s.array("Per-recipient submission results.", s.looseObject("One recipient result, including any additional provider fields.", {
+                msg_id: s.string("Message ID allocated by Picky Assist."),
+                number: s.string("Recipient phone number."),
+                credit: s.string("Credit charged as reported by the provider."),
+            })),
+        }),
+    }),
+];

package/src/providers/picky_assist/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/picky_assist/executors.js

@@ -0,0 +1,68 @@
+import { optionalRawString, recordOrEmpty, looseArray } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, readProviderTextBody, } from "../provider-runtime.js";
+import { pickyAssistActions } from "./actions.js";
+const baseUrl = "https://app.pickyassist.com/api/v2";
+function validateMessages(body) {
+    for (const entry of looseArray(body.data)) {
+        const recipient = recordOrEmpty(entry);
+        const recipientField = body.application === 5 ? "messenger_id" : "number";
+        requiredInputString(recipient[recipientField], `data[].${recipientField}`);
+        if (![recipient.message, recipient.media, body.globalmessage, body.globalmedia].some((value) => optionalRawString(value)?.trim())) {
+            throw new ProviderRequestError(400, "Each recipient requires text or media, either individual or global", undefined, "invalid_input");
+        }
+    }
+}
+async function request(endpoint, body, apiKey, fetcher, parentSignal) {
+    return runProviderRequest({ signal: parentSignal, label: "Picky Assist" }, async (signal) => {
+        const response = await fetcher(`${baseUrl}/${endpoint}`, {
+            method: "POST",
+            headers: { accept: "application/json", "content-type": "application/json" },
+            body: JSON.stringify({ ...body, token: apiKey }),
+            signal,
+        });
+        const payload = await readProviderTextBody(response, "picky_assist response", undefined, signal)
+            .then((text) => JSON.parse(text))
+            .catch((error) => {
+            if (error instanceof SyntaxError)
+                return null;
+            throw error;
+        });
+        const result = recordOrEmpty(payload);
+        if (!response.ok || result.status !== 100) {
+            const code = typeof result.status === "number" ? ` (status ${result.status})` : "";
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Picky Assist${code}: ${optionalRawString(result.message) ?? `request failed with HTTP ${response.status}`}`, undefined, "provider_error");
+        }
+        return requiredResponseRecord(payload, "Picky Assist response");
+    });
+}
+const handlers = mapProviderActionHandlers("picky_assist", pickyAssistActions, (action) => async (values, context) => {
+    if (action.name === "send_messages") {
+        validateMessages(values);
+    }
+    return request(action.name === "get_balance" ? "check-balance" : "push", values, requiredInputString(context.apiKey, "apiKey"), context.fetcher, context.signal);
+});
+export const executors = defineApiKeyProviderExecutors("picky_assist", handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        await request("check-balance", {}, requiredInputString(input.apiKey, "apiKey"), fetcher);
+        return {
+            profile: { displayName: "Picky Assist API Token" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "picky_assist",
+    baseUrl,
+    auth: { type: "api_key_json_body", name: "token" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+        if (!headers.has("content-type"))
+            headers.set("content-type", "application/json");
+    },
+});

package/src/providers/pixellab/runtime.js

@@ -1,6 +1,6 @@
 import { Buffer } from "node:buffer";
 import { base64Bytes, compactObject, optionalBoolean, optionalInteger, optionalNumber, optionalObjectArray, optionalRecord, optionalString, requiredRecord, requiredString, } from "../../core/cast.js";
-import { readBoundedResponseBytes } from "../../core/request.js";
+import { storeResponseInTransit } from "../../core/request.js";
 import { providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderJsonBody, readTransitFileInput, requiredInputString, } from "../provider-runtime.js";
 export const pixellabApiBaseUrl = "https://api.pixellab.ai/v2";
 const pixellabValidationPath = "/characters?limit=1&offset=0";
@@ -115,13 +115,14 @@ export async function downloadPixellabFile(path, name, context) {
         });
         throw createPixellabError(response, payload);
     }
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: context.transitFiles.maxBytes,
+    const mimeType = response.headers.get("content-type") ?? "application/octet-stream";
+    const stored = await storeResponseInTransit(response, context.transitFiles, {
+        name,
+        mimeType,
         fieldName: name,
         createError: (message) => new ProviderRequestError(413, message),
+        signal: context.signal,
     });
-    const mimeType = response.headers.get("content-type") ?? "application/octet-stream";
-    const stored = await context.transitFiles.create(new File([Uint8Array.from(bytes)], name, { type: mimeType }));
     return {
         fileId: stored.fileId,
         downloadUrl: stored.downloadUrl,

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

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

package/src/providers/planly/actions.js

@@ -0,0 +1,155 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const record = s.looseObject("Planly resource, including additional upstream fields.", {});
+const pagination = s.object("Cursor pagination options.", {
+    cursor: s.nullableString("Cursor from the previous data.next; omit for the first page."),
+    orderBy: s.tuple([
+        s.stringEnum("Sort property.", ["CreatedAt", "ContentLength"]),
+        s.stringEnum("Sort direction.", ["asc", "desc"]),
+    ], { description: "Sort property and direction." }),
+    pageSize: s.integer("Number of results; Planly defaults to 50.", { minimum: 1 }),
+}, {
+    optional: ["cursor", "orderBy", "pageSize"],
+});
+const pageInput = s.object("Team and pagination options.", {
+    teamId: s.nonEmptyString("Team ID returned by list_teams."),
+    pagination,
+}, {
+    optional: ["pagination"],
+});
+const error = s.nullable(s.looseObject("Upstream error details, or null on success.", {}));
+const envelope = (data) => s.object("Planly response envelope.", { data, error }, {
+    optional: ["error"],
+    additionalProperties: true,
+});
+const pageOutput = envelope(s.object("Page of Planly resources.", {
+    rows: s.array("Resources in this page.", record),
+    next: s.nullableString("Cursor for the next page, when available."),
+    totalNumberOfRows: s.integer("Total number of matching resources, when provided."),
+}, {
+    optional: ["next", "totalNumberOfRows"],
+    additionalProperties: true,
+}));
+const schedule = s.object("A post to publish on a connected social channel.", {
+    channelId: s.nonEmptyString("Connected channel ID returned by list_channels."),
+    publishOn: s.string("Publication date and time; omit to publish immediately.", {
+        format: "date-time",
+    }),
+    content: s.string("Text content for the post."),
+    media: s.array("Previously imported Planly media.", s.object("Media reference and platform options.", {
+        id: s.nonEmptyString("Planly media ID returned by import_media or list_media."),
+        options: s.looseObject("Platform-specific media options passed unchanged to Planly.", {}),
+    }, {
+        optional: ["options"],
+    })),
+    options: s.looseObject("Social-network options passed unchanged to Planly. Pinterest publishing requires boardId; TikTok requires privacyLevel. See https://docs.planly.com/#social-network-options for all platform fields.", {}),
+}, {
+    optional: ["publishOn", "content", "media", "options"],
+});
+export const planlyActions = [
+    defineProviderAction("planly", {
+        name: "list_teams",
+        operationType: "read",
+        description: "List the Planly teams accessible to the API key.",
+        requiredScopes: [],
+        inputSchema: s.object("No input is required.", {}, {
+            optional: [],
+        }),
+        outputSchema: envelope(s.array("Accessible teams.", s.looseObject("Planly team.", {
+            id: s.string("Team ID."),
+            name: s.string("Team name."),
+        }))),
+    }),
+    defineProviderAction("planly", {
+        name: "list_channels",
+        operationType: "read",
+        description: "List connected social channels in a Planly team.",
+        requiredScopes: [],
+        inputSchema: s.object("Channel list filters.", {
+            team_id: s.nonEmptyString("Team ID returned by list_teams."),
+            excludeCompetitors: s.boolean("Exclude competitor channels; defaults to false."),
+        }, {
+            optional: ["excludeCompetitors"],
+        }),
+        outputSchema: envelope(s.array("Connected channels.", s.looseObject("Planly channel.", {
+            id: s.string("Channel ID."),
+            name: s.string("Channel name."),
+            social_network: s.string("Social network identifier."),
+        }))),
+    }),
+    defineProviderAction("planly", {
+        name: "import_media",
+        operationType: "write",
+        description: "Import a public media URL into Planly. Supports MP4, PNG, JPEG and WebP.",
+        requiredScopes: [],
+        inputSchema: s.object("Media URL and destination team.", {
+            teamId: s.nonEmptyString("Destination team ID."),
+            url: s.string("Public media URL downloaded by Planly.", { format: "uri" }),
+        }, {
+            optional: [],
+        }),
+        outputSchema: envelope(s.looseObject("Imported media metadata.", {
+            id: s.string("Media ID for use in schedules."),
+            contentUri: s.string("Hosted media URL."),
+        })),
+    }),
+    defineProviderAction("planly", {
+        name: "list_media",
+        operationType: "read",
+        description: "List a page of media in a Planly team.",
+        requiredScopes: [],
+        inputSchema: pageInput,
+        outputSchema: pageOutput,
+    }),
+    defineProviderAction("planly", {
+        name: "delete_media",
+        operationType: "destructive",
+        description: "Delete media resources from Planly by ID.",
+        requiredScopes: [],
+        inputSchema: s.object("Media resources to delete.", {
+            ids: s.array("Media IDs to delete.", s.nonEmptyString("Media ID."), { minItems: 1 }),
+        }, {
+            optional: [],
+        }),
+        outputSchema: envelope(s.boolean("Whether the deletion succeeded.")),
+    }),
+    defineProviderAction("planly", {
+        name: "create_schedules",
+        operationType: "write",
+        description: "Create scheduled or immediate social posts in Planly. This endpoint creates scheduled posts, not drafts; publication status can be read with list_schedules.",
+        requiredScopes: [],
+        inputSchema: s.object("Posts to create.", {
+            schedules: s.array("Social posts to schedule.", schedule, { minItems: 1 }),
+        }, {
+            optional: [],
+        }),
+        outputSchema: envelope(s.looseObject("Created schedule groups.", {
+            upsert: s.array("Created groups with schedules and publication status.", record),
+        })),
+    }),
+    defineProviderAction("planly", {
+        name: "list_schedules",
+        operationType: "read",
+        description: "List a page of Planly schedules and their publication status.",
+        requiredScopes: [],
+        inputSchema: pageInput,
+        outputSchema: pageOutput,
+    }),
+    defineProviderAction("planly", {
+        name: "list_pinterest_boards",
+        operationType: "read",
+        description: "List boards for a connected Pinterest channel to obtain publishing board IDs.",
+        requiredScopes: [],
+        inputSchema: s.object("Pinterest channel to query.", {
+            channelId: s.nonEmptyString("Connected Pinterest channel ID."),
+        }, {
+            optional: [],
+        }),
+        outputSchema: envelope(s.looseObject("Pinterest boards result.", {
+            boards: s.array("Available boards.", s.looseObject("Pinterest board.", {
+                value: s.string("Board ID."),
+                label: s.string("Board name."),
+            })),
+        })),
+    }),
+];

package/src/providers/planly/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/planly/executors.js

@@ -0,0 +1,83 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { readProviderTextBody, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { planlyActions } from "./actions.js";
+const baseUrl = "https://app.planly.com/api";
+const endpoints = {
+    list_teams: "/teams/list",
+    list_channels: "/v2/channels/list",
+    import_media: "/v2/media/import-from-url",
+    list_media: "/v2/media/list",
+    delete_media: "/v2/media/delete",
+    create_schedules: "/v2/schedules/create",
+    list_schedules: "/v2/schedules/list",
+};
+async function requestPlanly(endpoint, body, apiKey, fetcher, parentSignal) {
+    return runProviderRequest({ signal: parentSignal, label: "Planly" }, async (signal) => {
+        const response = await fetcher(`${baseUrl}${endpoint}`, {
+            method: "POST",
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${apiKey}`,
+                "content-type": "application/json",
+            },
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal,
+        });
+        const text = await readProviderTextBody(response, "planly response", undefined, signal);
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Planly returned invalid JSON (HTTP ${response.status})`, undefined, "provider_error");
+        }
+        const record = optionalRecord(payload);
+        if (!response.ok || record?.error != null) {
+            const upstreamError = optionalRecord(record?.error);
+            const message = optionalRawString(upstreamError?.message) ??
+                optionalRawString(record?.error) ??
+                optionalRawString(record?.message) ??
+                `Planly request failed (HTTP ${response.status})`;
+            const code = optionalRawString(upstreamError?.code) ?? optionalRawString(record?.code);
+            throw new ProviderRequestError(response.ok ? 502 : response.status, code ? `${code}: ${message}` : message, undefined, "provider_error");
+        }
+        return requiredResponseRecord(payload, "Planly");
+    });
+}
+export const executors = defineApiKeyProviderExecutors("planly", mapProviderActionHandlers("planly", planlyActions, (_action, actionName) => async (input, context) => {
+    const body = input;
+    if (actionName === "list_pinterest_boards" && (body.channelId === "." || body.channelId === "..")) {
+        throw new ProviderRequestError(400, "Invalid Pinterest channel ID", undefined, "invalid_input");
+    }
+    const endpoint = actionName === "list_pinterest_boards"
+        ? `/v2/pinterest/get-board-list/${encodeURIComponent(String(body.channelId))}`
+        : endpoints[actionName];
+    if (!endpoint) {
+        throw new ProviderRequestError(400, `Unknown Planly endpoint: ${actionName}`, undefined, "invalid_input");
+    }
+    return requestPlanly(endpoint, actionName === "list_teams" || actionName === "list_pinterest_boards" ? undefined : body, context.apiKey, context.fetcher, context.signal);
+}), { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        const result = await requestPlanly("/teams/list", undefined, requiredInputString(input.apiKey, "API Key"), fetcher);
+        if (!Array.isArray(result.data)) {
+            throw new ProviderRequestError(502, "Planly returned an invalid team list", undefined, "provider_error");
+        }
+        return {
+            profile: { displayName: "Planly API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "planly",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [key, value] of Object.entries({ accept: "application/json" }))
+            if (!headers.has(key))
+                headers.set(key, value);
+    },
+});

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

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