@oomol-lab/open-connector 1.6.4 → 1.7.0

package/src/providers/outlook/microsoft-graph.js

@@ -1,5 +1,5 @@
 import { optionalRecord, optionalString } from "../../core/cast.js";
-import { ProviderRequestError, readProviderErrorTextBody, readProviderJsonBody, runProviderRequest, setSearchParams, } from "../provider-runtime.js";
+import { ProviderRequestError, readProviderErrorTextBody, readProviderJsonBody, runProviderRequest, setSearchParams, withRetryAfterSeconds, } from "../provider-runtime.js";
 const graphBaseUrl = "https://graph.microsoft.com/v1.0/";
 const graphOrigin = "https://graph.microsoft.com";
 /**
@@ -41,10 +41,13 @@ export async function microsoftGraphJson(pathOrUrl, options) {
     }));
 }
 function buildMicrosoftGraphUrl(pathOrUrl, query, allowNextLink) {
-    const normalizedPathOrUrl = pathOrUrl.toLowerCase();
-    const absolute = normalizedPathOrUrl.startsWith("https://") || normalizedPathOrUrl.startsWith("http://");
-    const requiresNextLinkValidation = absolute || pathOrUrl.startsWith("/");
-    const url = absolute ? new URL(pathOrUrl) : new URL(pathOrUrl, graphBaseUrl);
+    // Code passes plain relative paths such as `me/messages`; anything else is a
+    // caller-supplied link that must pass the allowlist. A value with any scheme
+    // is parsed on its own: resolved against the base, `https:me/drive` would
+    // turn into a same-origin path that never reaches the allowlist.
+    const absolute = /^[a-z][a-z\d+.-]*:/i.test(pathOrUrl);
+    const requiresNextLinkValidation = absolute || !/^[a-z\d]/i.test(pathOrUrl);
+    const url = parseMicrosoftGraphUrl(pathOrUrl, absolute ? undefined : graphBaseUrl);
     if (url.origin !== graphOrigin || url.protocol !== "https:") {
         throw new ProviderRequestError(400, "Microsoft Graph URL must target https://graph.microsoft.com");
     }
@@ -54,6 +57,14 @@ function buildMicrosoftGraphUrl(pathOrUrl, query, allowNextLink) {
     setSearchParams(url, query ?? {});
     return url;
 }
+function parseMicrosoftGraphUrl(pathOrUrl, base) {
+    try {
+        return new URL(pathOrUrl, base);
+    }
+    catch {
+        throw new ProviderRequestError(400, "Microsoft Graph URL must target https://graph.microsoft.com");
+    }
+}
 async function microsoftGraphResponseError(response, options) {
     const text = await readProviderErrorTextBody(response, `${options.label} error response`);
     let code = "";
@@ -69,5 +80,5 @@ async function microsoftGraphResponseError(response, options) {
             // Keep the upstream text when it is not JSON.
         }
     }
-    return new ProviderRequestError(response.status, options.refineErrorMessage?.(code, message) ?? message);
+    return new ProviderRequestError(response.status, options.refineErrorMessage?.(code, message) ?? message, withRetryAfterSeconds(response));
 }

package/src/providers/outlook_calendar/executors.js

@@ -97,19 +97,26 @@ async function getCalendar(input, context) {
     return microsoftGraphJson(`me/calendars/${encodePathSegment(id)}`, requestOptions(context, "get calendar", { $select: stringList(input.select) }));
 }
 async function listEvents(input, context, calendarView) {
-    const nextLinkValue = optionalString(input.nextLink);
+    // Graph v1.0 tracks calendar changes through calendarView/delta only
+    // (events/delta is a beta preview); a nextLink continues the current round,
+    // a deltaLink starts the next one.
+    const followUpLink = optionalString(input.nextLink) ?? (calendarView ? optionalString(input.deltaLink) : undefined);
+    const delta = calendarView && input.delta === true;
     const calendar = optionalString(input.calendarId);
     const collection = calendarView ? "calendarView" : "events";
-    const path = calendar ? `me/calendars/${encodePathSegment(calendar)}/${collection}` : `me/${collection}`;
-    const query = nextLinkValue
+    const path = `${calendar ? `me/calendars/${encodePathSegment(calendar)}/${collection}` : `me/${collection}`}${delta ? "/delta" : ""}`;
+    const query = followUpLink
         ? undefined
         : compactObject({
             ...listQuery(input),
             startDateTime: calendarView ? optionalString(input.startDateTime) : undefined,
             endDateTime: calendarView ? optionalString(input.endDateTime) : undefined,
         });
-    const payload = await microsoftGraphJson(nextLinkValue ?? path, requestOptions(context, `list ${calendarView ? "calendar view" : "events"}`, query, allowEventNextLink, preferTimeZone(input)));
-    return listOutput(payload, "events");
+    const payload = await microsoftGraphJson(followUpLink ?? path, requestOptions(context, `list ${calendarView ? "calendar view" : "events"}`, query, allowEventNextLink, preferTimeZone(input)));
+    // Rows stay raw so a delta round's `@removed` markers pass through. Only the
+    // calendar view has delta rounds, so only it reports a deltaLink.
+    const output = listOutput(payload, "events");
+    return calendarView ? { ...output, deltaLink: optionalString(payload["@odata.deltaLink"]) ?? null } : output;
 }
 async function getEvent(input, context) {
     const id = requiredInputString(input.eventId, "eventId");
@@ -212,16 +219,26 @@ function allowEventNextLink(pathname) {
         return true;
     }
     const segments = pathname.split("/").filter(Boolean);
+    // Delta links end in a trailing `delta` segment on the same three shapes,
+    // and only for calendarView: events/delta is not on Graph v1.0.
+    const delta = segments.length > 3 && segments[segments.length - 1] === "delta";
+    if (delta) {
+        segments.pop();
+    }
+    const isEventCollection = (segment) => segment === "calendarView" || (!delta && segment === "events");
+    if (delta && segments.length === 3 && segments[0] === "v1.0" && segments[1] === "me") {
+        return isEventCollection(segments[2]);
+    }
     if (segments.length === 4 &&
         segments[0] === "v1.0" &&
         segments[1] === "me" &&
         segments[2]?.startsWith("calendars('") &&
         segments[2].endsWith("')")) {
-        return segments[3] === "events" || segments[3] === "calendarView";
+        return isEventCollection(segments[3]);
     }
     return (segments.length === 5 &&
         segments[0] === "v1.0" &&
         segments[1] === "me" &&
         segments[2] === "calendars" &&
-        (segments[4] === "events" || segments[4] === "calendarView"));
+        isEventCollection(segments[4]));
 }

package/src/providers/patsnap_mcp/executors.js

@@ -37,7 +37,7 @@ export const proxy = defineProviderProxy({
         return endpoints.has(new URL(endpoint, patsnapMcpOrigin).href);
     },
     skipDnsValidation: true,
-    redirect: "error",
+    redirect: "manual",
     customizeRequest({ headers }) {
         headers.set("accept", "application/json, text/event-stream");
     },
@@ -95,7 +95,7 @@ async function withClient(context, server, run) {
         transport: "streamable_http",
         fetcher: context.fetcher,
         headers: { authorization: `Bearer ${context.apiKey}`, "user-agent": providerUserAgent },
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError: mapMcpError,
     }, run);

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

@@ -0,0 +1,108 @@
+import { compactObject, optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerUserAgent, readProviderJsonBody, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
+const service = "pdf_vector";
+const pdfVectorApiBaseUrl = "https://global.pdfvector.com/api";
+const credentialUrl = "https://global.pdfvector.com/rpc/authenticate/validateCredential";
+const handlers = {
+    parse_document(input, context) {
+        return executeDocumentAction("/document/parse", input, context);
+    },
+    ask_document(input, context) {
+        return executeDocumentAction("/document/ask", input, context);
+    },
+    extract_document(input, context) {
+        return executeDocumentAction("/document/extract", input, context);
+    },
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: pdfVectorApiBaseUrl,
+    auth: { type: "bearer" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+        headers.set("x-pdfvector-source", "oomol-connector");
+    },
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = await requestJson({
+            url: credentialUrl,
+            body: {},
+            context: { apiKey: input.apiKey, fetcher, signal },
+            phase: "validate",
+        });
+        const version = optionalString(optionalRecord(optionalRecord(payload)?.json)?.version);
+        if (!version)
+            throw new ProviderRequestError(502, "PDF Vector credential validation response did not include a server version");
+        return {
+            profile: { accountId: "pdf-vector-api-key", displayName: "PDF Vector API Key" },
+            grantedScopes: [],
+            metadata: {
+                apiBaseUrl: pdfVectorApiBaseUrl,
+                validationEndpoint: "/rpc/authenticate/validateCredential",
+                serverVersion: version,
+            },
+        };
+    },
+};
+function executeDocumentAction(path, input, context) {
+    return requestJson({
+        url: `${pdfVectorApiBaseUrl}${path}`,
+        body: compactObject({
+            url: requiredInputString(input.documentUrl, "documentUrl"),
+            model: optionalString(input.model),
+            includePages: input.includePages,
+            question: optionalString(input.question),
+            prompt: optionalString(input.prompt),
+            schema: optionalRecord(input.schema),
+        }),
+        documentId: optionalString(input.documentId),
+        context,
+        phase: "execute",
+    });
+}
+async function requestJson(input) {
+    return runProviderRequest({ signal: input.context.signal, label: "PDF Vector" }, async (signal) => {
+        const response = await input.context.fetcher(input.url, {
+            method: "POST",
+            headers: {
+                accept: "application/json",
+                authorization: `Bearer ${input.context.apiKey}`,
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+                "x-pdfvector-source": "oomol-connector",
+                ...(input.documentId ? { "x-pdfvector-document-id": input.documentId } : {}),
+            },
+            body: JSON.stringify(input.body),
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "PDF Vector returned invalid JSON",
+        });
+        if (!response.ok)
+            throw createError(response.status, payload, input.phase);
+        return payload;
+    });
+}
+function createError(status, payload, phase) {
+    const record = optionalRecord(payload);
+    const json = optionalRecord(record?.json);
+    const error = optionalRecord(record?.error);
+    const message = optionalString(json?.message) ??
+        optionalString(error?.message) ??
+        optionalString(record?.message) ??
+        `PDF Vector request failed with status ${status}`;
+    const code = optionalString(json?.code) ?? optionalString(error?.code) ?? optionalString(record?.code);
+    if (phase === "validate" && status === 401 && code === "UNAUTHORIZED")
+        return providerInputError(message);
+    if (status === 429)
+        return new ProviderRequestError(429, message, payload);
+    if (phase === "execute" && [400, 404, 422].includes(status))
+        return providerInputError(message);
+    return new ProviderRequestError(status || 502, message, payload);
+}

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

@@ -0,0 +1,83 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, ProviderRequestError, providerUserAgent, readProviderJsonBody, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const service = "postiz";
+const baseUrl = "https://api.postiz.com/public/v1";
+const handlers = {
+    list_integrations: async (input, context) => readPostizCollection(await request(context, "/integrations", { query: { group: optionalString(input.group) } }), "integrations"),
+    list_posts: async (input, context) => requiredResponseRecord(await request(context, "/posts", {
+        query: {
+            startDate: optionalString(input.startDate),
+            endDate: optionalString(input.endDate),
+            customer: optionalString(input.customer),
+        },
+    }), "Postiz posts"),
+    upload_from_url: async (input, context) => requiredResponseRecord(await request(context, "/upload-from-url", { method: "POST", body: { url: input.url } }), "Postiz uploaded media"),
+    create_post: async (input, context) => readPostizCollection(await request(context, "/posts", { method: "POST", body: input }), "created posts"),
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const result = optionalRecord(await request({ apiKey: input.apiKey, fetcher, signal }, "/is-connected"));
+        if (result?.connected !== true) {
+            throw new ProviderRequestError(502, "Postiz did not confirm the API key connection");
+        }
+        return {
+            profile: { accountId: "api_key", displayName: "Postiz API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl,
+    auth: { type: "api_key_header", name: "Authorization" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});
+async function request(context, path, options = {}) {
+    return runProviderRequest({ signal: context.signal, label: "Postiz" }, async (signal) => {
+        const url = new URL(`${baseUrl}${path}`);
+        for (const [key, value] of Object.entries(options.query ?? {})) {
+            if (value !== undefined)
+                url.searchParams.set(key, value);
+        }
+        const headers = new Headers({
+            accept: "application/json",
+            authorization: context.apiKey,
+            "user-agent": providerUserAgent,
+        });
+        if (options.body !== undefined)
+            headers.set("content-type", "application/json");
+        const response = await context.fetcher(url, {
+            method: options.method,
+            headers,
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: null,
+            invalidJsonMessage: "Postiz returned invalid JSON",
+            invalidJsonFallback: response.ok ? undefined : (text) => text,
+        });
+        if (!response.ok) {
+            const details = optionalRecord(payload);
+            const message = optionalString(details?.message) ??
+                optionalString(details?.error) ??
+                optionalString(payload) ??
+                `Postiz request failed with HTTP ${response.status}`;
+            throw new ProviderRequestError(response.status, message, payload);
+        }
+        return payload;
+    });
+}
+function readPostizCollection(value, label) {
+    if (!Array.isArray(value))
+        throw new ProviderRequestError(502, `Postiz returned invalid ${label}`);
+    return value;
+}

package/src/providers/provider-runtime.d.ts

@@ -284,6 +284,8 @@ export interface ProviderProxyDefinition {
     auth: ProviderProxyAuth;
     allowedEndpoint?: (endpoint: string) => boolean;
     customizeRequest?: (input: ProviderProxyRequestCustomizationInput) => Promise<void> | void;
+    /** Parse a failed HTTP response using the same provider error rules as actions. */
+    readError?: (response: Response) => Promise<ProviderRequestError>;
     /** Provider-specific credential/signature headers that redirects must not forward cross-origin. */
     sensitiveHeaders?: readonly string[];
     /** Exact code-controlled origins that `customizeRequest` may select in addition to the resolved base origin. */
@@ -299,6 +301,7 @@ export interface ProviderProxyDefinition {
     /** Deliberate provider-specific response byte cap; defaults to the shared 20 MiB limit. */
     maxResponseBytes?: number;
 }
+export declare const defaultProviderJsonMaxResponseBytes: number;
 export declare function createProviderProxyUrl(baseUrl: string, endpointInput: unknown, queryInput?: unknown, allowedOrigins?: readonly string[]): URL;
 export declare function normalizeProviderProxyEndpoint(endpointInput: unknown, allowedOrigins?: readonly string[]): string;
 export declare function normalizeProviderProxyQuery(queryInput: unknown): Record<string, string>;
@@ -369,6 +372,21 @@ export declare function setSearchParams(url: URL, query: Record<string, string |
  * Read a bounded provider error response body as text.
  */
 export declare function readProviderErrorTextBody(response: Response, fieldName: string): Promise<string>;
+/**
+ * Read a `Retry-After` header as whole seconds from now: an integer delay
+ * verbatim, an HTTP-date as the seconds until that instant (never negative).
+ * Examples: `"73" => 73`; a date 90 s ahead `=> 90`; absent or unparseable
+ * `=> undefined`.
+ */
+export declare function readRetryAfterSeconds(headers: Headers, now?: number): number | undefined;
+/**
+ * Attach a rate-limited response's `Retry-After` to its error details in the
+ * shape Slack established, `details.retryAfterSeconds`, so every provider's
+ * 429 (and 503) reaches the action envelope with the same pacing hint.
+ * Other statuses, and responses without a usable header, return `details`
+ * untouched; non-record details are kept under `body`.
+ */
+export declare function withRetryAfterSeconds(response: Response, details?: unknown): unknown;
 /**
  * Read a JSON provider response or raise a structured provider request error.
  */

package/src/providers/provider-runtime.js

@@ -125,7 +125,7 @@ const blockedProxyRequestHeaders = new Set([
     "transfer-encoding",
 ]);
 const defaultProviderProxyMaxResponseBytes = 20 * 1024 * 1024;
-const defaultProviderJsonMaxResponseBytes = 20 * 1024 * 1024;
+export const defaultProviderJsonMaxResponseBytes = 20 * 1024 * 1024;
 const defaultProviderErrorMaxResponseBytes = 64 * 1024;
 const defaultProviderRequestTimeoutMs = 30_000;
 export function createProviderProxyUrl(baseUrl, endpointInput, queryInput, allowedOrigins) {
@@ -264,6 +264,11 @@ export async function readProviderProxyResponse(response, options = {}) {
     };
 }
 export async function readProviderProxyErrorMessage(response, fallbackMessage) {
+    // An unfollowed redirect's body usually echoes its `Location`, which may carry a signed target URL.
+    if (response.status >= 300 && response.status < 400) {
+        await response.body?.cancel().catch(() => undefined);
+        return fallbackMessage;
+    }
     const bytes = await readBoundedResponseBytes(response, {
         maxBytes: defaultProviderProxyMaxResponseBytes,
         fieldName: "proxy error response",
@@ -356,6 +361,10 @@ export function defineProviderProxy(input) {
                 }
                 const response = await egressFetch(url, init);
                 if (!response.ok) {
+                    // A provider error parser would surface an unfollowed redirect's body; the shared reader withholds it.
+                    if (input.readError && (response.status < 300 || response.status >= 400)) {
+                        throw await input.readError(response);
+                    }
                     throw new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, `provider request failed with HTTP ${response.status}`));
                 }
                 return {
@@ -676,6 +685,52 @@ export async function readProviderErrorTextBody(response, fieldName) {
         return "";
     }
 }
+// The three HTTP-date forms of RFC 9110 section 5.6.7. Date.parse alone is too
+// lenient for a header: V8 reads "wait 5" as 1 May 2001, and reads the zone-less
+// asctime form as local time although every HTTP-date is UTC.
+const imfFixdatePattern = /^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun), \d{2} (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) \d{4} \d{2}:\d{2}:\d{2} GMT$/;
+const rfc850DatePattern = /^(?:Mon|Tues|Wednes|Thurs|Fri|Satur|Sun)day, \d{2}-(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\d{2} \d{2}:\d{2}:\d{2} GMT$/;
+const asctimeDatePattern = /^(?:Mon|Tue|Wed|Thu|Fri|Sat|Sun) (?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec) [ \d]\d \d{2}:\d{2}:\d{2} \d{4}$/;
+/**
+ * Read a `Retry-After` header as whole seconds from now: an integer delay
+ * verbatim, an HTTP-date as the seconds until that instant (never negative).
+ * Examples: `"73" => 73`; a date 90 s ahead `=> 90`; absent or unparseable
+ * `=> undefined`.
+ */
+export function readRetryAfterSeconds(headers, now = Date.now()) {
+    const value = headers.get("retry-after")?.trim();
+    if (!value) {
+        return undefined;
+    }
+    if (/^\d+$/.test(value)) {
+        const seconds = Number(value);
+        return Number.isSafeInteger(seconds) ? seconds : undefined;
+    }
+    const retryAt = imfFixdatePattern.test(value) || rfc850DatePattern.test(value)
+        ? Date.parse(value)
+        : asctimeDatePattern.test(value)
+            ? Date.parse(`${value} GMT`)
+            : Number.NaN;
+    return Number.isFinite(retryAt) ? Math.max(0, Math.ceil((retryAt - now) / 1000)) : undefined;
+}
+/**
+ * Attach a rate-limited response's `Retry-After` to its error details in the
+ * shape Slack established, `details.retryAfterSeconds`, so every provider's
+ * 429 (and 503) reaches the action envelope with the same pacing hint.
+ * Other statuses, and responses without a usable header, return `details`
+ * untouched; non-record details are kept under `body`.
+ */
+export function withRetryAfterSeconds(response, details) {
+    if (response.status !== 429 && response.status !== 503) {
+        return details;
+    }
+    const retryAfterSeconds = readRetryAfterSeconds(response.headers);
+    if (retryAfterSeconds === undefined) {
+        return details;
+    }
+    const record = optionalRecord(details) ?? (details == null ? {} : { body: details });
+    return { ...record, retryAfterSeconds };
+}
 /**
  * Read a JSON provider response or raise a structured provider request error.
  */
@@ -803,9 +858,10 @@ export function toProviderExecutionError(error, fallbackMessage) {
                         ? "authorization_failed"
                         : error.status === 429
                             ? "rate_limited"
-                            : error.status < 500
-                                ? "invalid_input"
-                                : "provider_error"),
+                            : // A 3xx is an upstream redirect that `redirect: "manual"` surfaced unfollowed, not bad input.
+                                error.status < 500 && (error.status < 300 || error.status >= 400)
+                                    ? "invalid_input"
+                                    : "provider_error"),
                 message: error.message,
                 details: {
                     status: error.status,

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

@@ -0,0 +1,135 @@
+import { compactObject, looseArray, optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, providerInputError, ProviderRequestError, providerUserAgent, readProviderJsonBody, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+const service = "proworkflow";
+const baseUrl = "https://api.proworkflow.com/api/v4";
+const handlers = {
+    list_projects: (input, context) => request(context, "/projects", { query: buildListQuery(input) }),
+    get_project: (input, context) => request(context, `/projects/${positiveInteger(input.projectId, "projectId")}`, {
+        query: { fields: input.fields },
+    }),
+    update_project: (input, context) => request(context, `/projects/${positiveInteger(input.projectId, "projectId")}`, {
+        method: "PUT",
+        body: requireUpdateFields(compactObject({
+            title: input.title,
+            number: input.number,
+            description: input.description,
+            startdate: input.startDate,
+            duedate: input.dueDate,
+            completedate: input.completedDate,
+            priorityid: input.priorityId,
+            managerid: input.managerId,
+            companyid: input.companyId,
+            notification: input.notification,
+        })),
+    }),
+    list_project_items: (input, context) => request(context, "/projects/items", {
+        query: { ...buildListQuery(input), projectid: input.projectId },
+    }),
+    get_project_item: (input, context) => request(context, `/projects/items/${positiveInteger(input.itemId, "itemId")}`),
+    update_project_item: (input, context) => request(context, `/projects/items/${positiveInteger(input.itemId, "itemId")}`, {
+        method: "PUT",
+        body: requireUpdateFields(compactObject({
+            name: input.name,
+            code: input.code,
+            description: input.description,
+            startdate: input.startDate,
+            duedate: input.dueDate,
+            completedate: input.completedDate,
+            status: input.status,
+            priorityid: input.priorityId,
+            manualPercentageComplete: input.percentComplete,
+        })),
+    }),
+};
+export const executors = defineApiKeyProviderExecutors(service, handlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = requiredResponseRecord(await request({ apiKey: input.apiKey, fetcher, signal }, "/settings/account", {}, "validate"), "ProWorkflow account settings response");
+        const data = requiredResponseRecord(payload.data, "ProWorkflow account settings data");
+        return {
+            profile: { accountId: "api_key", displayName: optionalString(data.accounturl) ?? "ProWorkflow API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationEndpoint: "/settings/account" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl,
+    auth: { type: "api_key_header", name: "apikey" },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});
+async function request(context, path, options = {}, phase = "execute") {
+    return runProviderRequest({ signal: context.signal, label: "ProWorkflow" }, async (signal) => {
+        const url = new URL(`${baseUrl}${path}`);
+        for (const [key, value] of Object.entries(options.query ?? {})) {
+            if (value != null && value !== "")
+                url.searchParams.set(key, String(value));
+        }
+        const response = await context.fetcher(url, {
+            method: options.method,
+            headers: {
+                accept: "application/json",
+                apikey: context.apiKey,
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+            },
+            body: options.body === undefined ? undefined : JSON.stringify(options.body),
+            signal,
+        });
+        const payload = await readProviderJsonBody(response, {
+            emptyBody: {},
+            invalidJsonMessage: "ProWorkflow returned invalid JSON",
+            trimEmptyBody: false,
+        });
+        if (!response.ok)
+            throw createError(response.status, payload, phase);
+        return requiredResponseRecord(payload, "ProWorkflow response");
+    });
+}
+function buildListQuery(input) {
+    if ((input.pageNumber == null) !== (input.pageSize == null)) {
+        throw providerInputError("pageNumber and pageSize must be provided together");
+    }
+    return {
+        fields: input.fields,
+        q: input.q,
+        status: input.status,
+        sortby: input.sortBy,
+        sortorder: input.sortOrder,
+        pagenumber: input.pageNumber,
+        pagesize: input.pageSize,
+        includetotalrows: input.includeTotalRows,
+        companyid: input.companyId,
+    };
+}
+function requireUpdateFields(body) {
+    if (Object.keys(body).length === 0)
+        throw providerInputError("at least one update field is required");
+    return body;
+}
+function positiveInteger(value, fieldName) {
+    if (typeof value !== "number" || !Number.isInteger(value) || value < 1) {
+        throw providerInputError(`${fieldName} must be a positive integer`);
+    }
+    return value;
+}
+function createError(status, payload, phase) {
+    const record = optionalRecord(payload);
+    const messages = looseArray(record?.data)
+        .filter((item) => typeof item === "string" && item.trim() !== "")
+        .join("; ");
+    const message = messages || optionalString(record?.message) || `ProWorkflow request failed with ${status}`;
+    if (status === 429)
+        return new ProviderRequestError(429, message, payload);
+    if (phase === "execute" && [400, 404, 422].includes(status)) {
+        return new ProviderRequestError(400, message, payload, "invalid_input");
+    }
+    return new ProviderRequestError(status || 500, message, payload);
+}

package/src/providers/pulsetic/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;