@oomol-lab/open-connector 1.6.2 → 1.6.3

package/src/providers/mojo_helpdesk/runtime.js

@@ -0,0 +1,173 @@
+import { compactObject, looseArray, optionalNumber, optionalRecord, optionalString } from "../../core/cast.js";
+import { providerInputError, ProviderRequestError, providerResponseError, providerUserAgent, readProviderJsonBody, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+export const mojoHelpdeskApiBaseUrl = "https://app.mojohelpdesk.com/api/v2";
+const validationPath = "/ticket_queues";
+export const mojoHelpdeskActionHandlers = {
+    async list_tickets(input, context) {
+        return {
+            tickets: requireArray(await requestMojo({
+                ...context,
+                path: "/tickets",
+                query: {
+                    sort_by: optionalString(input.sortBy),
+                    sort_order: optionalString(input.sortOrder),
+                    page: optionalNumber(input.page),
+                    per_page: optionalNumber(input.perPage),
+                },
+            }), "ticket list"),
+        };
+    },
+    async search_tickets(input, context) {
+        return {
+            tickets: requireArray(await requestMojo({
+                ...context,
+                path: "/tickets/search",
+                query: {
+                    query: optionalString(input.query),
+                    sf: optionalString(input.sortField),
+                    r: input.reverse === undefined ? undefined : input.reverse ? 1 : 0,
+                    page: optionalNumber(input.page),
+                    per_page: optionalNumber(input.perPage),
+                },
+            }), "ticket search"),
+        };
+    },
+    async get_ticket(input, context) {
+        return {
+            ticket: requiredResponseRecord(await requestMojo({ ...context, path: `/tickets/${requireId(input.ticketId, "ticketId")}` }), "Mojo Helpdesk ticket response"),
+        };
+    },
+    async create_ticket(input, context) {
+        return {
+            ticket: requiredResponseRecord(await requestMojo({ ...context, path: "/tickets", method: "POST", body: buildTicketBody(input) }), "Mojo Helpdesk ticket response"),
+        };
+    },
+    async update_ticket(input, context) {
+        return {
+            ticket: requiredResponseRecord(await requestMojo({
+                ...context,
+                path: `/tickets/${requireId(input.ticketId, "ticketId")}`,
+                method: "PUT",
+                body: buildTicketBody(input),
+            }), "Mojo Helpdesk ticket response"),
+        };
+    },
+    async list_comments(input, context) {
+        return {
+            comments: requireArray(await requestMojo({
+                ...context,
+                path: `/tickets/${requireId(input.ticketId, "ticketId")}/comments`,
+                query: { page: optionalNumber(input.page), per_page: optionalNumber(input.perPage) },
+            }), "comment list"),
+        };
+    },
+    async create_comment(input, context) {
+        return {
+            comment: requiredResponseRecord(await requestMojo({
+                ...context,
+                path: `/tickets/${requireId(input.ticketId, "ticketId")}/comments`,
+                method: "POST",
+                body: compactObject({
+                    body: optionalString(input.body),
+                    time_spent: optionalNumber(input.timeSpent),
+                    cc: optionalString(input.cc),
+                    user_id: optionalNumber(input.userId),
+                }),
+            }), "Mojo Helpdesk comment response"),
+        };
+    },
+    async list_ticket_queues(input, context) {
+        return {
+            ticketQueues: requireArray(await requestMojo({
+                ...context,
+                path: validationPath,
+                query: { page: optionalNumber(input.page), per_page: optionalNumber(input.perPage) },
+            }), "ticket queue list"),
+        };
+    },
+    async list_tags(input, context) {
+        return {
+            tags: requireArray(await requestMojo({
+                ...context,
+                path: "/tags",
+                query: { sort_by: optionalString(input.sortBy), sort_order: optionalString(input.sortOrder) },
+            }), "tag list"),
+        };
+    },
+};
+export async function validateMojoHelpdeskCredential(apiKey, fetcher, signal) {
+    requireArray(await requestMojo({ apiKey, fetcher, signal, path: validationPath, query: { page: 1, per_page: 1 } }), "ticket queue list");
+    return {
+        profile: { accountId: "mojo_helpdesk", displayName: "Mojo Helpdesk API Key" },
+        grantedScopes: [],
+        metadata: { apiBaseUrl: mojoHelpdeskApiBaseUrl, validationEndpoint: validationPath },
+    };
+}
+function buildTicketBody(input) {
+    const body = compactObject({
+        title: optionalString(input.title),
+        description: optionalString(input.description),
+        ticket_queue_id: optionalNumber(input.ticketQueueId),
+        priority_id: optionalNumber(input.priorityId),
+        status_id: optionalNumber(input.statusId),
+        ticket_type_id: optionalNumber(input.ticketTypeId),
+        assigned_to_id: optionalNumber(input.assignedToId),
+        ticket_form_id: optionalNumber(input.ticketFormId),
+        user_id: optionalNumber(input.userId),
+        user: input.userEmail ? { email: input.userEmail } : undefined,
+        cc: optionalString(input.cc),
+        asset_tag: optionalString(input.assetTag),
+        asset_id: optionalNumber(input.assetId),
+        due_on: optionalString(input.dueOn),
+        scheduled_on: optionalString(input.scheduledOn),
+        resolution_id: optionalNumber(input.resolutionId),
+    });
+    for (const [key, value] of Object.entries(optionalRecord(input.customFields) ?? {})) {
+        body[`custom_field_${key}`] = value;
+    }
+    return body;
+}
+async function requestMojo(options) {
+    return runProviderRequest({ label: "Mojo Helpdesk", signal: options.signal }, async (signal) => {
+        const url = new URL(`${mojoHelpdeskApiBaseUrl}${options.path}`);
+        for (const [key, value] of Object.entries(options.query ?? {})) {
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        }
+        const headers = new Headers({
+            accept: "application/json",
+            "user-agent": providerUserAgent,
+            "x-api-key": options.apiKey,
+        });
+        if (options.body !== undefined)
+            headers.set("content-type", "application/json");
+        const response = await options.fetcher(url, {
+            method: options.method ?? "GET",
+            headers,
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: {},
+            invalidJsonMessage: "Mojo Helpdesk returned invalid JSON",
+        });
+        if (!response.ok) {
+            const body = optionalRecord(payload);
+            throw new ProviderRequestError(response.status || 502, optionalString(body?.message) ??
+                optionalString(body?.error) ??
+                `Mojo Helpdesk API request failed with status ${response.status}`);
+        }
+        return payload;
+    });
+}
+function requireId(value, fieldName) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+        throw providerInputError(`${fieldName} must be a positive integer`);
+    }
+    return value;
+}
+function requireArray(value, label) {
+    if (!Array.isArray(value))
+        throw providerResponseError(`Mojo Helpdesk ${label} must be an array`);
+    return looseArray(value);
+}

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

@@ -0,0 +1,99 @@
+import { compactObject, optionalRecord, optionalString, objectArray, requiredBoolean, requiredRecord, requiredString, requiredStringArray, } from "../../core/cast.js";
+import { readProviderTextBody } from "../provider-runtime.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerResponseError, providerUserAgent, } from "../provider-runtime.js";
+const service = "mumble";
+const baseUrl = "https://app.mumble.co.il/mumbleapi";
+const handlers = {
+    create_customer: (input, context) => mutate("/add-new-customer", "POST", customerBody(input), context),
+    update_customer: (input, context) => mutate("/edit-customer", "POST", { ...optionalRecord(input.customFields), ...customerBody(input) }, context),
+    async get_customer(input, context) {
+        const data = requiredRecord(await request("/get-customer", "GET", context, undefined, {
+            customer_phone: requiredString(input.customerPhone, "customerPhone"),
+        }), "Mumble response");
+        return { customer: requiredRecord(data.customer, "Mumble customer") };
+    },
+    async list_customers(input, context) {
+        const data = requiredRecord(await request("/get-all-customers", "GET", context, undefined, input.page === undefined ? undefined : { page: String(input.page) }), "Mumble response");
+        return {
+            customers: objectArray(data.customers, "Mumble customers", providerResponseError),
+            total: data.total ?? null,
+            currentPage: data.current_page ?? null,
+            perPage: data.per_page ?? null,
+            totalPages: data.total_pages ?? data.pages ?? null,
+        };
+    },
+    delete_customer: (input, context) => mutate("/delete-customer", "DELETE", { customer_phone: requiredString(input.customerPhone, "customerPhone") }, context),
+    create_label: (input, context) => mutate("/add-new-label", "POST", { label_name: requiredString(input.labelName, "labelName") }, context),
+    async list_labels(_input, context) {
+        const data = requiredRecord(await request("/get-labels", "GET", context), "Mumble response");
+        return { labels: requiredStringArray(data.labels, "Mumble labels", providerResponseError) };
+    },
+    delete_label: (input, context) => mutate("/delete-label", "DELETE", { label_name: requiredString(input.labelName, "labelName") }, context),
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl,
+    auth: { type: "api_key_header", name: "Mumble-Api-Key" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const context = { apiKey: input.apiKey, fetcher, signal };
+        await handlers.list_labels({}, context);
+        return {
+            profile: { displayName: "Mumble API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationEndpoint: "/get-labels" },
+        };
+    },
+};
+function customerBody(input) {
+    return {
+        ...optionalRecord(input.marketingAttribution),
+        ...compactObject({
+            customer_phone: requiredString(input.customerPhone, "customerPhone"),
+            name: optionalString(input.name),
+            email: optionalString(input.email),
+            source: optionalString(input.source),
+            bot_token: optionalString(input.botToken),
+        }),
+    };
+}
+async function mutate(path, method, body, context) {
+    const data = requiredRecord(await request(path, method, context, body), "Mumble response");
+    return { success: requiredBoolean(data.success, "Mumble success"), message: optionalString(data.message) ?? null };
+}
+async function request(path, method, context, body, query) {
+    const url = new URL(`${baseUrl}${path}`);
+    for (const [key, value] of Object.entries(query ?? {}))
+        url.searchParams.set(key, value);
+    const response = await context.fetcher(url, {
+        method,
+        headers: {
+            accept: "application/json",
+            "content-type": "application/json",
+            "mumble-api-key": context.apiKey,
+            "user-agent": providerUserAgent,
+        },
+        body: body ? JSON.stringify(body) : undefined,
+        signal: context.signal,
+    });
+    const text = await readProviderTextBody(response, "Mumble response");
+    let data = null;
+    try {
+        data = text ? JSON.parse(text) : null;
+    }
+    catch {
+        throw new ProviderRequestError(502, "Mumble returned invalid JSON");
+    }
+    if (!response.ok) {
+        const record = optionalRecord(data);
+        throw new ProviderRequestError(response.status, optionalString(record?.message) ??
+            optionalString(record?.error) ??
+            `Mumble request failed with status ${response.status}`);
+    }
+    return data;
+}

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

@@ -3,6 +3,15 @@ import type { ProviderActionHandlers } from "../provider-runtime.ts";
 interface NotionActionContext {
     accessToken: string;
     fetcher: typeof fetch;
+    /**
+     * The stored credential's runtime metadata. For an OAuth credential this is
+     * the token-exchange response minus its secrets — `workspace_id`, `owner`,
+     * `bot_id`, `workspace_name` — merged with the `/users/me` bot object the
+     * validator stored, whose `bot` carries `workspace_id`, `owner` and
+     * `workspace_name` as well. For an internal integration only the latter
+     * exists. `get_current_user` reads both here and makes no request.
+     */
+    metadata: Record<string, unknown>;
 }
 type NotionActionHandler = (input: Record<string, unknown>, context: NotionActionContext) => Promise<unknown>;
 export declare const notionActionHandlers: ProviderActionHandlers<"notion", NotionActionHandler>;

package/src/providers/notion/executors.js

@@ -5,6 +5,9 @@ const notionApiBaseUrl = "https://api.notion.com/v1";
 const notionFetch = createProviderFetch({ skipDnsValidation: true });
 const notionCoreVersion = "2026-03-11";
 export const notionActionHandlers = {
+    get_current_user(_input, context) {
+        return Promise.resolve(notionGetCurrentUser(context.metadata));
+    },
     search(input, context) {
         return notionSearch(input, context.accessToken, context.fetcher);
     },
@@ -86,8 +89,14 @@ export const executors = defineProviderExecutors({
     handlers: notionActionHandlers,
     skipDnsValidation: true,
     async createContext(context, fetcher) {
-        const credential = await requireBearerCredential(context, service);
-        return { accessToken: credential.accessToken, fetcher };
+        // Resolved ONCE: a resolution may refresh the token, and the bearer
+        // helper would resolve it a second time.
+        const stored = await context.getCredential(service);
+        return {
+            accessToken: bearerTokenOf(stored),
+            fetcher,
+            metadata: stored && stored.authType !== "no_auth" ? stored.metadata : {},
+        };
     },
 });
 export const proxy = async (input, context) => {
@@ -124,10 +133,89 @@ export const credentialValidators = {
     async apiKey(input, { fetcher }) {
         return validateNotionCredential(input.apiKey, fetcher);
     },
+    /**
+     * The profile is the OWNING USER, not the bot.
+     *
+     * `GET /users/me` under an OAuth token describes the integration's bot, and
+     * a bot id is a UUID like any member's — so a consumer that linked the
+     * connecting person to this profile's `accountId` would bind them to a
+     * principal that authorizes nobody, with nothing anywhere looking wrong.
+     * The grant was requested with `owner=user`, so the exchange response
+     * already names the human; it is on `input.metadata`. The liveness call
+     * still runs, because that is what proves the token works.
+     */
     async oauth2(input, { fetcher }) {
-        return validateNotionCredential(input.accessToken, fetcher);
+        const live = await validateNotionCredential(input.accessToken, fetcher);
+        const owner = grantOwner(input.metadata);
+        if (!owner) {
+            return live;
+        }
+        return {
+            profile: {
+                accountId: owner.id,
+                displayName: owner.name ?? live.profile.displayName,
+            },
+            metadata: live.metadata,
+        };
     },
 };
+/** The token's bearer value, whichever stored kind carries it. */
+function bearerTokenOf(credential) {
+    if (credential?.authType === "oauth2") {
+        return credential.accessToken;
+    }
+    if (credential?.authType === "api_key") {
+        return credential.apiKey;
+    }
+    throw new ProviderRequestError(401, `Configure ${service} credentials first.`);
+}
+/**
+ * The person named as the credential's owner, or `undefined` when none is
+ * (a grant whose `owner.type` is `workspace`, which is every internal
+ * integration). Notion states the owner twice: at the top level of the token
+ * exchange, and under `bot.owner` of the `/users/me` bot object the validator
+ * stored. The exchange is read first, the bot object when it is absent.
+ */
+function grantOwner(metadata) {
+    const owner = asObject(metadata.owner) ?? asObject(asObject(metadata.bot)?.owner);
+    if (owner?.type !== "user") {
+        return undefined;
+    }
+    const user = asObject(owner.user);
+    const id = asNonEmptyString(user?.id);
+    return id ? { id, name: asNonEmptyString(user?.name) } : undefined;
+}
+/**
+ * `get_current_user`: the workspace and owner of the credential, and nothing
+ * else, read from what is already stored with it.
+ *
+ * The workspace id has two sources and neither costs a request: the OAuth
+ * token exchange names it as `workspace_id`, and the `/users/me` bot object
+ * the validator stored names it as `bot.workspace_id` for OAuth grants and
+ * internal integrations alike. Refuses rather than guesses when neither is
+ * present, which means the credential was stored without its bot object and
+ * needs to be validated again.
+ */
+function notionGetCurrentUser(metadata) {
+    const bot = asObject(metadata.bot);
+    const workspaceId = asNonEmptyString(metadata.workspace_id) ?? asNonEmptyString(bot?.workspace_id);
+    if (!workspaceId) {
+        // No explicit code: `providerErrorCodes` is the vocabulary a provider may
+        // put on the wire, and a missing credential field is not in it. The
+        // convention this follows is `provider-runtime.ts`'s own
+        // "credential metadata is missing …" — a plain 400 — with a message that
+        // says which field and what to do instead of only naming it.
+        throw new ProviderRequestError(400, "the stored Notion credential carries no workspace_id; reconnect Notion so its bot object is stored with the credential");
+    }
+    const owner = grantOwner(metadata);
+    return {
+        workspaceId,
+        workspaceName: asNonEmptyString(metadata.workspace_name) ?? asNonEmptyString(bot?.workspace_name) ?? null,
+        userId: owner?.id ?? null,
+        userName: owner?.name ?? null,
+        isBot: owner === undefined,
+    };
+}
 async function validateNotionCredential(accessToken, fetcher) {
     const profile = await fetchNotionCurrentAccount(accessToken, fetcher);
     return {
@@ -171,15 +259,82 @@ async function notionRetrievePage(input, accessToken, fetcher) {
     }, fetcher);
     return page ?? {};
 }
+/**
+ * The revision of whatever `pageId` names, and the reachability check that
+ * comes with reading it.
+ *
+ * **Pages and blocks both**, because this action's input has always been
+ * documented as "the page or block ID" and its description as "a Notion page
+ * **or block subtree**". A preflight that only knew `GET /pages/{id}` turned
+ * the advertised block-subtree flow into a 404 before the render was ever
+ * attempted — Notion answers `object_not_found` for a block id there.
+ *
+ * Pages first, since that is the overwhelmingly common input and costs one
+ * request; a 404 falls through to `/blocks/{id}`, which carries its own
+ * `last_edited_time`. Any other status propagates unchanged: a 401, 403 or
+ * 429 is an answer about the credential, not about which kind of id this is,
+ * and retrying it against a second endpoint would only double the cost and
+ * blur the error.
+ */
+async function notionLastEditedTime(id, accessToken, fetcher) {
+    for (const path of [`/pages/${id}`, `/blocks/${id}`]) {
+        let object;
+        try {
+            object = (await notionRequest(accessToken, { path }, fetcher)) ?? {};
+        }
+        catch (error) {
+            if (error instanceof ProviderRequestError && error.status === 404 && !path.startsWith("/blocks/")) {
+                continue;
+            }
+            throw error;
+        }
+        // A successful answer settles which kind of id this is. Only a 404 falls
+        // through, so an object Notion returned without a revision is malformed
+        // rather than a reason to consult the other endpoint.
+        const lastEditedTime = asNonEmptyString(object.last_edited_time);
+        if (!lastEditedTime) {
+            throw new ProviderRequestError(502, `Notion returned ${id} without a last_edited_time`);
+        }
+        return lastEditedTime;
+    }
+    // Unreachable: the block attempt either returns, rethrows its own 404, or
+    // throws the 502 above. Kept so the bounded loop has an explicit tail.
+    throw new ProviderRequestError(502, `Notion answered neither /pages nor /blocks for ${id}`);
+}
+/**
+ * One page or block subtree as Markdown.
+ *
+ * Two requests, the object first: it is the cheap question ("can this grant
+ * reach this, and when did it last change") and answers a 404 before the
+ * expensive render is attempted. The markdown response has no revision of its
+ * own, so `lastEditedTime` comes from that object.
+ *
+ * **Notion's fields keep Notion's names.** This action shipped with the
+ * provider, so its body is a contract SDK and CLI callers already read; the
+ * response is forwarded and the two constructed fields are added beside it.
+ * `pageId` is echoed from the INPUT — Notion may spell an id dashed or
+ * undashed in its own body, and a consumer joining rows to bindings needs the
+ * spelling it asked with.
+ */
 async function notionRetrievePageMarkdown(input, accessToken, fetcher) {
     const pageId = String(input.pageId);
-    const payload = await notionRequest(accessToken, {
+    const lastEditedTime = await notionLastEditedTime(pageId, accessToken, fetcher);
+    const rendered = (await notionRequest(accessToken, {
         path: `/pages/${pageId}/markdown`,
         query: compactQuery({
             include_transcript: typeof input.includeTranscript === "boolean" ? String(input.includeTranscript) : undefined,
         }),
-    }, fetcher);
-    return payload ?? {};
+    }, fetcher)) ?? {};
+    return {
+        ...rendered,
+        markdown: typeof rendered.markdown === "string" ? rendered.markdown : "",
+        truncated: rendered.truncated === true,
+        unknown_block_ids: Array.isArray(rendered.unknown_block_ids)
+            ? rendered.unknown_block_ids.filter((id) => typeof id === "string")
+            : [],
+        pageId,
+        lastEditedTime,
+    };
 }
 async function notionRetrievePageProperty(input, accessToken, fetcher) {
     const payload = await notionRequest(accessToken, {

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

@@ -0,0 +1,120 @@
+import { objectArray, optionalRecord, optionalString, requiredRecord, requiredString } from "../../core/cast.js";
+import { readProviderTextBody } from "../provider-runtime.js";
+import { basicAuthorizationHeader, defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, providerResponseError, providerUserAgent, ProviderRequestError, } from "../provider-runtime.js";
+const service = "omise", baseUrl = "https://api.omise.co";
+const handlers = {
+    async get_account(_i, c) {
+        return { account: requiredRecord(await request("/account", c), "Omise account") };
+    },
+    async get_balance(_i, c) {
+        return { balance: requiredRecord(await request("/balance", c), "Omise balance") };
+    },
+    async list_customers(i, c) {
+        return normalizeList(await request("/customers", c, "GET", undefined, i), "customers");
+    },
+    async get_customer(i, c) {
+        return {
+            customer: requiredRecord(await request(`/customers/${segment(i.customer_id, "customer_id")}`, c), "Omise customer"),
+        };
+    },
+    async create_customer(i, c) {
+        return { customer: requiredRecord(await request("/customers", c, "POST", customerForm(i)), "Omise customer") };
+    },
+    async update_customer(i, c) {
+        const form = customerForm(i);
+        if (!form.size)
+            throw providerInputError("update_customer requires email, description, or metadata");
+        return {
+            customer: requiredRecord(await request(`/customers/${segment(i.customer_id, "customer_id")}`, c, "PATCH", form), "Omise customer"),
+        };
+    },
+    async delete_customer(i, c) {
+        return {
+            customer: requiredRecord(await request(`/customers/${segment(i.customer_id, "customer_id")}`, c, "DELETE"), "Omise customer"),
+        };
+    },
+    async list_charges(i, c) {
+        return normalizeList(await request("/charges", c, "GET", undefined, i), "charges");
+    },
+    async get_charge(i, c) {
+        return {
+            charge: requiredRecord(await request(`/charges/${segment(i.charge_id, "charge_id")}`, c), "Omise charge"),
+        };
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl,
+    auth: { type: "api_key_basic", suffix: ":" },
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const account = requiredRecord(await request("/account", { apiKey: input.apiKey, fetcher, signal }), "Omise account");
+        const id = optionalString(account.id)?.trim();
+        return {
+            profile: {
+                accountId: id,
+                displayName: optionalString(account.email)?.trim() || (id ? `Omise ${id}` : "Omise Account"),
+            },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationEndpoint: "/account" },
+        };
+    },
+};
+function segment(value, name) {
+    return encodeURIComponent(requiredString(value, name));
+}
+function customerForm(input) {
+    const form = new URLSearchParams();
+    for (const key of ["email", "description"]) {
+        const value = optionalString(input[key]);
+        if (value !== undefined)
+            form.set(key, value);
+    }
+    for (const [key, value] of Object.entries(optionalRecord(input.metadata) ?? {}))
+        if (["string", "number", "boolean"].includes(typeof value))
+            form.set(`metadata[${key}]`, String(value));
+    return form;
+}
+function normalizeList(value, name) {
+    const record = requiredRecord(value, `Omise ${name}`);
+    const pagination = { ...record };
+    delete pagination.data;
+    return { [name]: objectArray(record.data, `Omise ${name} list data`, providerResponseError), pagination };
+}
+async function request(path, context, method = "GET", form, query) {
+    const url = new URL(path, baseUrl);
+    for (const [key, value] of Object.entries(query ?? {}))
+        if (typeof value === "string" || typeof value === "number")
+            url.searchParams.set(key, String(value));
+    const response = await context.fetcher(url, {
+        method,
+        headers: {
+            accept: "application/json",
+            authorization: basicAuthorizationHeader(`${context.apiKey}:`),
+            "user-agent": providerUserAgent,
+            "content-type": "application/x-www-form-urlencoded",
+        },
+        body: form,
+        signal: context.signal,
+    });
+    const text = await readProviderTextBody(response, "Omise response");
+    let payload = null;
+    try {
+        payload = text ? JSON.parse(text) : null;
+    }
+    catch {
+        if (response.ok)
+            throw new ProviderRequestError(502, "Omise returned invalid JSON");
+        payload = text;
+    }
+    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));
+    }
+    return payload;
+}

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

@@ -0,0 +1,14 @@
+import type { ActionDefinition, JsonSchema } from "../../core/types.ts";
+type ActionAsyncLifecycle = NonNullable<ActionDefinition["asyncLifecycle"]>;
+interface PanjivaActionSpec {
+    name: string;
+    path: string;
+    method: "GET" | "POST";
+    description: string;
+    inputSchema: JsonSchema;
+    outputSchema: JsonSchema;
+    asyncLifecycle?: ActionAsyncLifecycle;
+}
+export declare const panjivaActionSpecs: PanjivaActionSpec[];
+export declare const panjivaActions: readonly ActionDefinition[];
+export {};