@oomol-lab/open-connector 1.8.0 → 1.9.0

package/src/providers/pointagram/actions.js

@@ -0,0 +1,167 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const playerId = s.integer("The Pointagram player ID.");
+const teamId = s.integer("The Pointagram team ID.");
+const playerFields = {
+    player_name: s.nonWhitespaceString("The player's name in Pointagram."),
+    player_email: s.string("The player's email address, used for invitations."),
+    player_external_id: s.string("Your external identifier for the player."),
+    offline: s.stringEnum("Use 1 for offline or 0 for online; online players receive an invitation.", ["0", "1"]),
+};
+const teamFields = {
+    team_name: s.nonWhitespaceString("The team's name in Pointagram."),
+    icon: s.nonWhitespaceString("An existing Pointagram icon filename, such as Bulls.png, or a previously uploaded custom icon."),
+    filter_ignore: s.stringEnum("Use 1 to exempt this team from filter settings, or 0 otherwise.", ["0", "1"]),
+};
+const envelope = (data) => s.looseObject("The Pointagram response envelope.", {
+    status: s.string("The upstream operation status."),
+    message: s.string("The upstream operation message."),
+    data,
+});
+const player = s.looseObject("A Pointagram player; additional upstream fields are preserved.", {
+    id: s.string("The player ID returned by Pointagram."),
+    name: s.string("The player's name."),
+    emailaddress: s.string("The player's email address."),
+    external_id: s.string("The player's external identifier."),
+});
+const team = s.looseObject("A Pointagram team; additional upstream fields are preserved.", {
+    id: s.string("The team ID returned by Pointagram."),
+    name: s.string("The team's name."),
+    icon: s.string("The team's icon filename."),
+});
+const mutationOutput = envelope(s.looseObject("Operation details, including any created resource ID.", {
+    profile_id: s.string("The created or updated player ID, when returned."),
+    team_id: s.string("The created or updated team ID, when returned."),
+}));
+export const pointagramActions = [
+    defineProviderAction("pointagram", {
+        name: "list_players",
+        operationType: "read",
+        description: "List or search Pointagram players. Continue with data.pagination.next_offset; offset is a player ID, not a row count.",
+        inputSchema: s.object("Player search and pagination parameters.", {
+            search_by: s.string("Search by Email, Name or External Id."),
+            filter: s.string("The value to search for."),
+            limit: s.integer("Maximum players per page; default 50, maximum 1000.", {
+                minimum: 1,
+                maximum: 1000,
+            }),
+            offset: s.string("The last player ID from the previous page."),
+        }, {
+            required: [],
+        }),
+        outputSchema: envelope(s.looseObject("Players and pagination information.", {
+            players: s.array("The matching players.", player),
+            pagination: s.looseObject("Pagination cursors returned by Pointagram.", {
+                limit: s.string("The page size returned by Pointagram."),
+                offset: s.string("The current cursor."),
+                next_offset: s.string("The player ID to use as the next offset."),
+            }),
+        })),
+    }),
+    defineProviderAction("pointagram", {
+        name: "get_player",
+        operationType: "read",
+        description: "Get a Pointagram player by ID.",
+        inputSchema: s.requiredObject("Player lookup parameters.", { player_id: playerId }),
+        outputSchema: envelope(s.looseObject("The player details returned by Pointagram.", {})),
+    }),
+    defineProviderAction("pointagram", {
+        name: "create_player",
+        operationType: "write",
+        description: "Create a Pointagram player. Online players receive an invitation; an existing player produces a conflict.",
+        inputSchema: s.object("New player details.", playerFields, {
+            required: ["player_name"],
+        }),
+        outputSchema: mutationOutput,
+    }),
+    defineProviderAction("pointagram", {
+        name: "update_player",
+        operationType: "write",
+        description: "Update a Pointagram player using the provided fields.",
+        inputSchema: {
+            ...s.object("Player ID and fields to update.", { player_id: playerId, ...playerFields }, {
+                required: ["player_id"],
+            }),
+            minProperties: 2,
+        },
+        outputSchema: mutationOutput,
+    }),
+    defineProviderAction("pointagram", {
+        name: "delete_player",
+        operationType: "destructive",
+        description: "Soft-delete a Pointagram player. Administrators cannot be removed. Complete anonymization requires the Pointagram UI; inspect the upstream status and message.",
+        inputSchema: s.requiredObject("Player to soft-delete.", { player_id: playerId }),
+        outputSchema: mutationOutput,
+    }),
+    defineProviderAction("pointagram", {
+        name: "list_teams",
+        operationType: "read",
+        description: "List Pointagram teams.",
+        inputSchema: s.requiredObject("No input parameters are required.", {}),
+        outputSchema: envelope(s.looseObject("Team listing.", { teams: s.array("The teams.", team) })),
+    }),
+    defineProviderAction("pointagram", {
+        name: "get_team",
+        operationType: "read",
+        description: "Get a Pointagram team by ID.",
+        inputSchema: s.requiredObject("Team lookup parameters.", { team_id: teamId }),
+        outputSchema: envelope(team),
+    }),
+    defineProviderAction("pointagram", {
+        name: "create_team",
+        operationType: "write",
+        description: "Create a Pointagram team with an existing icon filename.",
+        inputSchema: s.object("New team details.", teamFields, {
+            required: ["team_name", "icon"],
+        }),
+        outputSchema: mutationOutput,
+    }),
+    defineProviderAction("pointagram", {
+        name: "update_team",
+        operationType: "write",
+        description: "Update a Pointagram team's name, icon and filter settings.",
+        inputSchema: s.object("Team ID and replacement team details.", { team_id: teamId, ...teamFields }, {
+            required: ["team_id", "team_name", "icon"],
+        }),
+        outputSchema: mutationOutput,
+    }),
+    defineProviderAction("pointagram", {
+        name: "list_team_players",
+        operationType: "read",
+        description: "List the players belonging to a Pointagram team.",
+        inputSchema: s.requiredObject("Team membership lookup parameters.", { team_id: teamId }),
+        outputSchema: envelope(s.looseObject("Team membership details.", {
+            players: s.array("Players belonging to the team.", s.looseObject("A team member.", {
+                profile_id: s.string("The player's profile ID."),
+                name: s.string("The player's name."),
+            })),
+        })),
+    }),
+    defineProviderAction("pointagram", {
+        name: "add_team_player",
+        operationType: "write",
+        description: "Add a player to a Pointagram team using a player ID, email address or external ID.",
+        inputSchema: {
+            ...s.object("Team and player identifiers.", {
+                team_id: teamId,
+                player_id: playerId,
+                player_email: s.nonWhitespaceString("The email address identifying the player."),
+                player_external_id: s.nonWhitespaceString("The external ID identifying the player."),
+            }, {
+                required: ["team_id"],
+            }),
+            anyOf: [{ required: ["player_id"] }, { required: ["player_email"] }, { required: ["player_external_id"] }],
+        },
+        outputSchema: mutationOutput,
+    }),
+    defineProviderAction("pointagram", {
+        name: "remove_team_player",
+        operationType: "write",
+        description: "Remove a player from a Pointagram team's membership without deleting the player.",
+        inputSchema: s.requiredObject("Team and player IDs for membership removal.", {
+            team_id: teamId,
+            player_id: playerId,
+        }),
+        outputSchema: mutationOutput,
+    }),
+];

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

@@ -0,0 +1,107 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { defineProviderExecutors, requireApiKeyCredential, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, providerResponseError, requiredInputString, requiredResponseRecord, runProviderRequest, readProviderTextBody, } from "../provider-runtime.js";
+import { pointagramActions } from "./actions.js";
+const baseUrl = "https://app.pointagram.com/api/20";
+const defaultHeaders = { accept: "application/json", "content-type": "application/json" };
+const routes = {
+    list_players: { method: "GET", path: "/players" },
+    get_player: { method: "GET", path: "/players/{player_id}" },
+    create_player: { method: "POST", path: "/players" },
+    update_player: { method: "POST", path: "/players/{player_id}" },
+    delete_player: { method: "DELETE", path: "/players/{player_id}" },
+    list_teams: { method: "GET", path: "/teams" },
+    get_team: { method: "GET", path: "/teams/{team_id}" },
+    create_team: { method: "POST", path: "/teams" },
+    update_team: { method: "POST", path: "/teams/{team_id}" },
+    list_team_players: { method: "GET", path: "/teams/{team_id}/players" },
+    add_team_player: { method: "POST", path: "/teams/{team_id}/players" },
+    remove_team_player: { method: "DELETE", path: "/teams/{team_id}/{player_id}" },
+};
+async function request(url, method, body, apiKey, apiUser, fetcher, parentSignal) {
+    return runProviderRequest({ label: "Pointagram", signal: parentSignal }, async (signal) => {
+        const response = await fetcher(url, {
+            method,
+            signal,
+            headers: { ...defaultHeaders, "Api-Key": apiKey, "Api-User": apiUser },
+            body: body === undefined ? undefined : JSON.stringify(body),
+        });
+        const text = await readProviderTextBody(response, "pointagram response", undefined, signal);
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        const record = optionalRecord(payload);
+        const upstreamStatus = optionalRawString(record?.status);
+        if (!response.ok || upstreamStatus?.toLowerCase() === "error" || upstreamStatus?.toLowerCase() === "not found") {
+            const message = optionalRawString(record?.message) || text || `Pointagram request failed with status ${response.status}`;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, message.split(apiKey).join("[REDACTED]"), undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return requiredResponseRecord(payload, "Pointagram response");
+    });
+}
+const handlers = mapProviderActionHandlers("pointagram", pointagramActions, (action) => async (values, context) => {
+    const { apiKey, fetcher } = context;
+    const route = routes[action.name];
+    const fields = { ...values };
+    let path = route.path;
+    for (const key of ["team_id", "player_id"]) {
+        if (path.includes(`{${key}}`)) {
+            path = path.replace(`{${key}}`, encodeURIComponent(String(fields[key])));
+            delete fields[key];
+        }
+    }
+    const url = new URL(`${baseUrl}${path}`);
+    if (route.method === "GET") {
+        for (const [key, value] of Object.entries(fields)) {
+            if (value !== undefined)
+                url.searchParams.set(key, String(value));
+        }
+    }
+    return request(url, route.method, route.method === "POST" ? fields : undefined, apiKey, requiredInputString(context.apiUser, "apiUser"), fetcher, context.signal);
+});
+export const executors = defineProviderExecutors({
+    service: "pointagram",
+    handlers,
+    async createContext(context, fetcher) {
+        const credential = await requireApiKeyCredential(context, "pointagram");
+        return {
+            apiKey: credential.apiKey,
+            fetcher,
+            signal: context.signal,
+            apiUser: credential.values?.apiUser,
+        };
+    },
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const payload = await request(new URL(`${baseUrl}/test`), "POST", undefined, requiredInputString(input.apiKey, "API Key"), requiredInputString(input.values.apiUser, "apiUser"), fetcher, signal);
+        if (payload.status !== "Ok") {
+            throw providerResponseError("Pointagram credential test did not confirm valid credentials");
+        }
+        return {
+            profile: { displayName: optionalRawString(optionalRecord(payload.data)?.organization) || "Pointagram API Key" },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "pointagram",
+    baseUrl,
+    auth: {
+        type: "credential_headers",
+        headers: [
+            { name: "Api-Key", source: { type: "api_key" } },
+            { name: "Api-User", source: { type: "credential_value", name: "apiUser" } },
+        ],
+    },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries(defaultHeaders))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+});

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

@@ -1,3 +1,4 @@
+import type { ProviderDispatchContext, ProviderHttpDispatchOptions } from "../core/provider-http-dispatch.ts";
 import type { ActionExecutor, ExecutionContext, ExecutionResult, ProviderExecutors, ProviderProxyExecutor, ProxyExecutionResult, ProxyResponse, ResolvedCredential, TransitFileWriter } from "../core/types.ts";
 import type { ProviderActionNames } from "./action-contracts.generated.ts";
 /**
@@ -37,6 +38,8 @@ export declare function createProviderFetch(options?: ProviderFetchOptions): Pro
  * the native fetch is always invoked without a stray receiver.
  */
 export declare const providerFetch: ProviderFetch;
+/** Preserve admission denials at the shared runtime boundary despite provider-specific error mapping. */
+export declare function withProviderHttpDispatchResult<T>(context: ProviderDispatchContext, run: () => T | Promise<T>, options?: ProviderHttpDispatchOptions): Promise<T>;
 /**
  * Default User-Agent sent by local provider executors.
  */
@@ -149,6 +152,10 @@ export declare class ProviderRequestError extends Error {
     readonly code?: string;
     constructor(status: number, message: string, details?: unknown, code?: string);
 }
+/** A dispatch denial is retryable and must not be wrapped as a bad provider credential. */
+export declare class ProviderDispatchRequestError extends ProviderRequestError {
+    constructor(retryAfterSeconds?: number);
+}
 /**
  * Return the 400 error providers throw for invalid action input or credentials.
  * The message is surfaced verbatim as the `invalid_input` execution error.
@@ -371,7 +378,7 @@ 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>;
+export declare function readProviderErrorTextBody(response: Response, fieldName: string, signal?: AbortSignal): 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).
@@ -402,7 +409,7 @@ export interface ReadProviderJsonBodyOptions {
 /**
  * Read a bounded provider response body as text.
  */
-export declare function readProviderTextBody(response: Response, fieldName: string, maxBytes?: number): Promise<string>;
+export declare function readProviderTextBody(response: Response, fieldName: string, maxBytes?: number, signal?: AbortSignal): Promise<string>;
 /**
  * Read a bounded provider response body as JSON.
  */

package/src/providers/provider-runtime.js

@@ -1,6 +1,7 @@
 import { Buffer } from "node:buffer";
 import { CastError, optionalRecord, optionalScalarString, optionalString, requiredNumber, requiredRecord, requiredString, } from "../core/cast.js";
 import { createGuardedFetch } from "../core/guarded-fetch.js";
+import { dispatchProviderHttpAttempt, ProviderHttpDispatchError, runWithProviderHttpDispatch, } from "../core/provider-http-dispatch.js";
 import { readBoundedResponseBytes } from "../core/request.js";
 /**
  * Create the SSRF-guarded fetch used for all provider egress: the request URL,
@@ -10,6 +11,16 @@ import { readBoundedResponseBytes } from "../core/request.js";
  */
 export function createProviderFetch(options = {}) {
     return createGuardedFetch({
+        dispatchAttempt: async (attempt, signal, transport, revalidate) => {
+            try {
+                return await dispatchProviderHttpAttempt(attempt, signal, transport, revalidate);
+            }
+            catch (error) {
+                if (error instanceof ProviderHttpDispatchError)
+                    throw new ProviderDispatchRequestError(error.retryAfterSeconds);
+                throw error;
+            }
+        },
         fetch: options.fetch,
         allowPrivateNetwork: options.allowPrivateNetwork,
         skipDnsValidation: options.skipDnsValidation,
@@ -32,6 +43,17 @@ export function createProviderFetch(options = {}) {
  * the native fetch is always invoked without a stray receiver.
  */
 export const providerFetch = createProviderFetch();
+/** Preserve admission denials at the shared runtime boundary despite provider-specific error mapping. */
+export async function withProviderHttpDispatchResult(context, run, options) {
+    try {
+        return await runWithProviderHttpDispatch(context, run, options);
+    }
+    catch (error) {
+        if (error instanceof ProviderHttpDispatchError)
+            throw new ProviderDispatchRequestError(error.retryAfterSeconds);
+        throw error;
+    }
+}
 /**
  * Default User-Agent sent by local provider executors.
  */
@@ -79,6 +101,12 @@ export class ProviderRequestError extends Error {
         this.code = code;
     }
 }
+/** A dispatch denial is retryable and must not be wrapped as a bad provider credential. */
+export class ProviderDispatchRequestError extends ProviderRequestError {
+    constructor(retryAfterSeconds) {
+        super(429, "Provider HTTP dispatch is temporarily unavailable.", { retryAfterSeconds }, "rate_limited");
+    }
+}
 /**
  * Return the 400 error providers throw for invalid action input or credentials.
  * The message is surfaced verbatim as the `invalid_input` execution error.
@@ -269,12 +297,10 @@ export async function readProviderProxyErrorMessage(response, fallbackMessage) {
         await response.body?.cancel().catch(() => undefined);
         return fallbackMessage;
     }
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: defaultProviderProxyMaxResponseBytes,
-        fieldName: "proxy error response",
-        createError: (message) => new ProviderRequestError(413, message),
-    });
-    return bytes.byteLength === 0 ? fallbackMessage : new TextDecoder().decode(bytes) || fallbackMessage;
+    // Error text is diagnostic and must never turn an upstream failure into a 413
+    // invalid_input. Share the error cap and the empty-on-failure behavior with
+    // readProviderErrorTextBody.
+    return (await readProviderErrorTextBody(response, "proxy error response")) || fallbackMessage;
 }
 function isTextProxyContentType(contentType) {
     const normalized = contentType.toLowerCase();
@@ -677,11 +703,20 @@ export function setSearchParams(url, query) {
 /**
  * Read a bounded provider error response body as text.
  */
-export async function readProviderErrorTextBody(response, fieldName) {
+export async function readProviderErrorTextBody(response, fieldName, signal) {
     try {
-        return await readProviderTextBody(response, fieldName, defaultProviderErrorMaxResponseBytes);
+        return await readProviderTextBody(response, fieldName, defaultProviderErrorMaxResponseBytes, signal);
     }
-    catch {
+    catch (error) {
+        // A size-limit or broken-body failure degrades to the fallback message, but
+        // a timeout, abort, or the caller's own abort reason must keep propagating
+        // so runProviderRequest reports 504 instead of the upstream status the body
+        // read was interrupted for. `AbortSignal.abort(reason)` accepts arbitrary
+        // reasons, which `isAbortLikeError` alone cannot recognize.
+        if (signal?.aborted)
+            throw signal.reason;
+        if (isAbortLikeError(error))
+            throw error;
         return "";
     }
 }
@@ -744,11 +779,12 @@ export async function readProviderJson(response, source) {
 /**
  * Read a bounded provider response body as text.
  */
-export async function readProviderTextBody(response, fieldName, maxBytes = defaultProviderJsonMaxResponseBytes) {
+export async function readProviderTextBody(response, fieldName, maxBytes = defaultProviderJsonMaxResponseBytes, signal) {
     const bytes = await readBoundedResponseBytes(response, {
         maxBytes,
         fieldName,
         createError: (message) => new ProviderRequestError(413, message),
+        signal,
     });
     return new TextDecoder().decode(bytes);
 }
@@ -785,6 +821,7 @@ export async function uploadProviderUrlToTransitFile(input, context) {
     if (!context.transitFiles) {
         return null;
     }
+    const transitFiles = context.transitFiles;
     let response;
     try {
         response = await context.fetcher(input.url, {
@@ -796,21 +833,38 @@ export async function uploadProviderUrlToTransitFile(input, context) {
         });
     }
     catch (error) {
+        if (isAbortLikeError(error) || isAbortSignalError(context.signal, error)) {
+            throw new ProviderRequestError(504, `${input.source} transit download timed out`);
+        }
         throw new ProviderRequestError(502, error instanceof Error
             ? `${input.source} transit download failed: ${error.message}`
             : `${input.source} transit download failed`);
     }
+    // An abort that lands after the response headers arrive rejects the body read
+    // outside the fetch catch above, so map it here too.
+    const readTransitBody = async (read) => {
+        try {
+            return await read();
+        }
+        catch (error) {
+            if (isAbortLikeError(error) || isAbortSignalError(context.signal, error)) {
+                throw new ProviderRequestError(504, `${input.source} transit download timed out`);
+            }
+            throw error;
+        }
+    };
     if (!response.ok) {
-        const text = await readProviderErrorTextBody(response, `${input.source} error response`);
+        const text = await readTransitBody(() => readProviderErrorTextBody(response, `${input.source} error response`, context.signal));
         throw new ProviderRequestError(response.status >= 500 ? 502 : response.status, text || `${input.source} transit download failed with HTTP ${response.status}`);
     }
     const mimeType = response.headers.get("content-type") ?? "application/octet-stream";
-    const bytes = await readBoundedResponseBytes(response, {
-        maxBytes: context.transitFiles.maxBytes,
+    const bytes = await readTransitBody(() => readBoundedResponseBytes(response, {
+        maxBytes: transitFiles.maxBytes,
         fieldName: input.name,
         createError: (message) => new ProviderRequestError(413, message),
-    });
-    const upload = await context.transitFiles.create(new File([Uint8Array.from(bytes)], input.name, { type: mimeType }));
+        signal: context.signal,
+    }));
+    const upload = await transitFiles.create(new File([Uint8Array.from(bytes)], input.name, { type: mimeType }));
     return {
         fileId: upload.fileId,
         downloadUrl: upload.downloadUrl,

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

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

package/src/providers/pushinator/actions.js

@@ -0,0 +1,34 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+export const pushinatorActions = [
+    defineProviderAction("pushinator", {
+        name: "send_notification",
+        operationType: "write",
+        description: "Send a push notification to the subscribers of a Pushinator channel.",
+        requiredScopes: [],
+        inputSchema: s.object("The notification to send.", {
+            channel_id: s.string("The UUID of the channel to send the notification to.", {
+                format: "uuid",
+            }),
+            content: s.nonEmptyString("The message content of the notification."),
+            acknowledgment_required: s.optional(s.boolean("Whether subscriber acknowledgment is required. Defaults to false; treated as false on the Free plan. Unacknowledged notifications retry up to five times with exponential backoff.")),
+        }, { optional: [] }),
+        outputSchema: s.looseRequiredObject("The notification submission result, not a delivery receipt.", {
+            success: s.boolean("Whether Pushinator accepted the notification."),
+            message: s.string("The human-readable response message."),
+        }),
+    }),
+    defineProviderAction("pushinator", {
+        name: "create_channel",
+        operationType: "write",
+        description: "Create a Pushinator channel for notification subscribers.",
+        requiredScopes: [],
+        inputSchema: s.object("The channel to create.", {
+            name: s.nonEmptyString("The name of the channel."),
+            description: s.optional(s.string("The description of the channel.")),
+        }, { optional: [] }),
+        outputSchema: s.object("The created channel result.", {
+            channel: s.looseObject("The channel properties returned by Pushinator, preserved without renaming."),
+        }, { optional: [] }),
+    }),
+];

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

@@ -0,0 +1,61 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, } from "../provider-runtime.js";
+import { pushinatorActions } from "./actions.js";
+const apiBaseUrl = "https://api.pushinator.com/api/v2";
+export const executors = defineApiKeyProviderExecutors("pushinator", mapProviderActionHandlers("pushinator", pushinatorActions, (_action, actionName) => async (input, context) => {
+    const apiKey = requiredInputString(context.apiKey, "API Key");
+    const fetcher = context.fetcher;
+    const path = actionName === "send_notification" ? "/notifications/send" : "/channels";
+    return runProviderRequest({ label: "Pushinator", signal: context.signal }, async (signal) => {
+        const response = await fetcher(`${apiBaseUrl}${path}`, {
+            method: "POST",
+            headers: {
+                accept: "application/json",
+                "content-type": "application/json",
+                "user-agent": providerUserAgent,
+                authorization: `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify(input),
+            signal,
+        });
+        const text = await response.text();
+        let payload;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            throw new ProviderRequestError(response.ok ? 502 : response.status, "Pushinator returned invalid JSON", undefined, "provider_error");
+        }
+        const record = optionalRecord(payload);
+        if (!response.ok || record?.success === false) {
+            const message = optionalString(record?.message) ?? response.statusText;
+            throw new ProviderRequestError(response.ok ? 502 : response.status, `Pushinator request failed: ${message}`, undefined, "provider_error");
+        }
+        const result = requiredResponseRecord(payload, "Pushinator response");
+        return actionName === "create_channel" ? { channel: result } : result;
+    });
+}), { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input) {
+        requiredInputString(input.apiKey, "API Key");
+        return {
+            profile: { displayName: "Pushinator API Key" },
+            grantedScopes: [],
+            metadata: {
+                apiBaseUrl,
+                validationMode: "local_non_empty_key",
+                validationReason: "official_api_only_documents_write_endpoints",
+            },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "pushinator",
+    baseUrl: apiBaseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        if (!headers.has("accept"))
+            headers.set("accept", "application/json");
+    },
+});

package/src/providers/quickbooks/constants.d.ts

@@ -0,0 +1,18 @@
+export type QuickbooksEnvironment = "production" | "sandbox";
+/** Accounting API hosts. The environment selects one of these; no credential value becomes a URL. */
+export declare const quickbooksBaseUrls: Record<QuickbooksEnvironment, string>;
+/** Sent as `minorversion` on every request. Intuit serves minor versions 1-74 as 75 since 2025-08-01. */
+export declare const quickbooksMinorVersion = "75";
+/** Largest `MAXRESULTS` the query endpoint accepts. */
+export declare const quickbooksMaxResults = 1000;
+/** Page size used when a list action does not set `max_results`. */
+export declare const quickbooksDefaultMaxResults = 100;
+/** Entity name used in query statements and the lowercase path segment used by CRUD endpoints. */
+export interface QuickbooksEntity {
+    name: string;
+    path: string;
+}
+/** The only OAuth scope the QuickBooks Online Accounting API needs; it covers reads and writes. */
+export declare const quickbooksAccountingScope = "com.intuit.quickbooks.accounting";
+/** Intuit OAuth token endpoint; the refresh hook receives no token URL, so it is pinned here to match `definition.ts`. */
+export declare const quickbooksTokenUrl = "https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer";

package/src/providers/quickbooks/constants.js

@@ -0,0 +1,15 @@
+/** Accounting API hosts. The environment selects one of these; no credential value becomes a URL. */
+export const quickbooksBaseUrls = {
+    production: "https://quickbooks.api.intuit.com",
+    sandbox: "https://sandbox-quickbooks.api.intuit.com",
+};
+/** Sent as `minorversion` on every request. Intuit serves minor versions 1-74 as 75 since 2025-08-01. */
+export const quickbooksMinorVersion = "75";
+/** Largest `MAXRESULTS` the query endpoint accepts. */
+export const quickbooksMaxResults = 1000;
+/** Page size used when a list action does not set `max_results`. */
+export const quickbooksDefaultMaxResults = 100;
+/** The only OAuth scope the QuickBooks Online Accounting API needs; it covers reads and writes. */
+export const quickbooksAccountingScope = "com.intuit.quickbooks.accounting";
+/** Intuit OAuth token endpoint; the refresh hook receives no token URL, so it is pinned here to match `definition.ts`. */
+export const quickbooksTokenUrl = "https://oauth.platform.intuit.com/oauth2/v1/tokens/bearer";

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

@@ -0,0 +1,9 @@
+import type { CredentialValidators, ProviderExecutors } from "../../core/types.ts";
+import type { ProviderRuntimeHandler } from "../provider-runtime.ts";
+import type { QuickbooksContext } from "./runtime.ts";
+export { oauth } from "./oauth.ts";
+type QuickbooksHandler = ProviderRuntimeHandler<QuickbooksContext>;
+/** Generated CRUD handlers first so the hand-written handlers override them. */
+export declare const quickbooksActionHandlers: Record<string, QuickbooksHandler>;
+export declare const executors: ProviderExecutors;
+export declare const credentialValidators: CredentialValidators;