@oomol-lab/open-connector 1.7.0 → 1.9.0

package/src/providers/greip/actions.js

@@ -0,0 +1,107 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const mode = s.stringEnum("Environment; test returns simulated data, live is the default.", ["live", "test"]);
+const countryFields = {
+    countryCode: s.string("ISO country code."),
+    countryName: s.string("Country name."),
+};
+const ipData = s.object("IP geolocation and optional enrichment modules.", {
+    ip: s.string("The queried IP address."),
+    ipType: s.string("IP address version."),
+    ...countryFields,
+    cityName: s.string("City name."),
+    latitude: s.string("Latitude coordinate."),
+    longitude: s.string("Longitude coordinate."),
+    asn: s.looseObject("Autonomous system details.", {}),
+    security: s.looseObject("Proxy, Tor, hosting and other security signals.", {}),
+    currency: s.looseObject("Currency details.", {}),
+    timezone: s.looseObject("Timezone details.", {}),
+    location: s.looseObject("Additional location details.", {}),
+}, {
+    required: ["ip"],
+    additionalProperties: true,
+});
+function envelope(data) {
+    return s.object("Greip response with the original data and response metadata.", {
+        data,
+        status: s.string("Response status."),
+        executionTime: s.number("Processing time in milliseconds."),
+    }, {
+        required: ["data", "status"],
+        additionalProperties: true,
+    });
+}
+export const greipActions = [
+    defineProviderAction("greip", {
+        name: "lookup_ip",
+        operationType: "read",
+        description: "Look up an IPv4 or IPv6 address with optional location and security enrichment.",
+        requiredScopes: [],
+        inputSchema: s.object("IP lookup parameters.", {
+            ip: s.nonEmptyString("IPv4 or IPv6 address to look up."),
+            params: s.array("Optional enrichment modules; availability depends on the plan.", s.stringEnum("Enrichment module.", ["security", "currency", "timezone", "location"]), { minItems: 1, uniqueItems: true }),
+            lang: s.stringEnum("Response language; EN is the default.", ["EN", "AR", "DE", "FR", "ES", "JA", "ZH", "RU"]),
+            mode,
+            userID: s.nonEmptyString("Optional user identifier for tracking requests in Greip events."),
+        }, {
+            optional: ["params", "lang", "mode", "userID"],
+        }),
+        outputSchema: envelope(ipData),
+    }),
+    defineProviderAction("greip", {
+        name: "lookup_asn",
+        operationType: "read",
+        description: "Look up an autonomous system number, its organization and network prefixes.",
+        requiredScopes: [],
+        inputSchema: s.object("ASN lookup parameters.", {
+            asn: s.nonEmptyString("Autonomous system number, with or without the AS prefix, such as AS6167 or 6167."),
+            mode,
+        }, {
+            optional: ["mode"],
+        }),
+        outputSchema: envelope(s.object("Autonomous system information.", {
+            asn: s.string("Autonomous system number."),
+            name: s.string("Autonomous system name."),
+            country: s.string("Country code."),
+            org: s.string("Organization name."),
+            prefixes: s.looseObject("Network prefixes advertised by the autonomous system.", {
+                ipv4: s.array("IPv4 network prefixes.", s.string("IPv4 network prefix.")),
+                ipv6: s.array("IPv6 network prefixes.", s.string("IPv6 network prefix.")),
+                total: s.integer("Total number of prefixes."),
+            }),
+        }, {
+            required: ["asn"],
+            additionalProperties: true,
+        })),
+    }),
+    defineProviderAction("greip", {
+        name: "lookup_country",
+        operationType: "read",
+        description: "Look up country information with optional language, flag, currency and timezone details.",
+        requiredScopes: [],
+        inputSchema: s.object("Country lookup parameters.", {
+            CountryCode: s.string("Two-letter country code, such as GB.", {
+                minLength: 2,
+                maxLength: 2,
+            }),
+            params: s.array("Optional country detail modules.", s.stringEnum("Country detail module.", ["language", "flag", "currency", "timezone"]), { minItems: 1, uniqueItems: true }),
+            mode,
+        }, {
+            optional: ["params", "mode"],
+        }),
+        outputSchema: envelope(s.object("Country information and requested detail modules.", {
+            ...countryFields,
+            capital: s.string("Capital city."),
+            population: s.integer("Country population."),
+            phoneCode: s.string("International calling code."),
+            countryIsEU: s.boolean("Whether the country is an EU member."),
+            language: s.looseObject("Language details.", {}),
+            flag: s.looseObject("Flag emoji and image URLs.", {}),
+            currency: s.looseObject("Currency details.", {}),
+            timezone: s.looseObject("Timezone details.", {}),
+        }, {
+            required: ["countryCode"],
+            additionalProperties: true,
+        })),
+    }),
+];

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

@@ -0,0 +1,84 @@
+import { isIP } from "node:net";
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { readProviderTextBody, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, ProviderRequestError, providerUserAgent, requiredInputString, requiredResponseRecord, runProviderRequest, isAbortLikeError, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { greipActions } from "./actions.js";
+const baseUrl = "https://greipapi.com";
+const endpoints = {
+    lookup_ip: "/lookup/ip",
+    lookup_asn: "/lookup/asn",
+    lookup_country: "/lookup/country",
+};
+async function request(endpoint, input, apiKey, fetcher, validating = false, parentSignal) {
+    const url = new URL(endpoint, baseUrl);
+    for (const [key, value] of Object.entries(input)) {
+        if (value != null)
+            url.searchParams.set(key, Array.isArray(value) ? value.join(",") : String(value));
+    }
+    url.searchParams.set("format", "JSON");
+    return runProviderRequest({ signal: parentSignal, label: "Greip" }, async (signal) => {
+        const response = await fetcher(url, {
+            signal,
+            headers: {
+                authorization: `Bearer ${apiKey}`,
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+            },
+        });
+        let payload;
+        try {
+            payload = await JSON.parse(await readProviderTextBody(response, "greip response", undefined, signal));
+        }
+        catch (error) {
+            if (error instanceof ProviderRequestError || isAbortLikeError(error))
+                throw error;
+            if (response.ok)
+                throw new ProviderRequestError(502, "Greip returned invalid JSON", undefined, "provider_error");
+        }
+        const body = optionalRecord(payload);
+        if (!response.ok || body?.status === "error") {
+            const description = optionalRawString(body?.description) ?? `Greip HTTP ${response.status}`;
+            const message = `${optionalRawString(body?.type) ?? "Greip error"}: ${description}`.replaceAll(apiKey, "[REDACTED]");
+            if (body?.status === "error" && (body.code === 101 || body.type === "invalid_key")) {
+                throw new ProviderRequestError(validating ? 400 : 409, message, undefined, validating ? "invalid_input" : "authorization_failed");
+            }
+            const limited = response.status === 429 || (body?.status === "error" && (body.code === 103 || body.code === 106));
+            throw new ProviderRequestError(limited ? 429 : response.ok ? 502 : response.status, message, withRetryAfterSeconds(response), limited ? "rate_limited" : "provider_error");
+        }
+        const result = requiredResponseRecord(payload, "Greip response");
+        requiredResponseRecord(result.data, "Greip response data");
+        return result;
+    });
+}
+export const executors = defineApiKeyProviderExecutors("greip", mapProviderActionHandlers("greip", greipActions, (_action, actionName) => async (input, context) => {
+    const data = { ...input };
+    if (data.CountryCode !== undefined)
+        data.CountryCode = requiredInputString(data.CountryCode, "CountryCode").toUpperCase();
+    if (actionName === "lookup_ip" && !isIP(String(data.ip))) {
+        throw new ProviderRequestError(400, "ip must be an IPv4 or IPv6 address", undefined, "invalid_input");
+    }
+    return request(endpoints[actionName], data, context.apiKey, context.fetcher, undefined, context.signal);
+}), { skipDnsValidation: true });
+export const credentialValidators = {
+    async apiKey(input, { fetcher }) {
+        await request("/lookup/ip", { ip: "1.1.1.1" }, requiredInputString(input.apiKey, "API Key"), fetcher, true);
+        return {
+            profile: { displayName: "Greip API Key" },
+            grantedScopes: [],
+            metadata: { validationEndpoint: "/lookup/ip" },
+        };
+    },
+};
+export const proxy = defineProviderProxy({
+    service: "greip",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    customizeRequest({ headers }) {
+        for (const [key, value] of Object.entries({
+            accept: "application/json",
+            "user-agent": providerUserAgent,
+        }))
+            if (!headers.has(key))
+                headers.set(key, value);
+    },
+});

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

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

package/src/providers/greynoise/executors.js

@@ -0,0 +1,17 @@
+import { defineProviderExecutors, defineProviderProxy } from "../provider-runtime.js";
+import { greynoiseActionHandlers, greynoiseApiBaseUrl } from "./runtime.js";
+const service = "greynoise";
+export const executors = defineProviderExecutors({
+    service,
+    handlers: greynoiseActionHandlers,
+    skipDnsValidation: true,
+    createContext(context, fetcher) {
+        return { fetcher, signal: context.signal };
+    },
+});
+export const proxy = defineProviderProxy({
+    service,
+    baseUrl: greynoiseApiBaseUrl,
+    auth: { type: "none" },
+    skipDnsValidation: true,
+});

package/src/providers/greynoise/runtime.d.ts

@@ -0,0 +1,9 @@
+import type { ProviderActionHandlers, ProviderFetch } from "../provider-runtime.ts";
+export declare const greynoiseApiBaseUrl = "https://api.greynoise.io";
+export interface GreynoiseRuntimeContext {
+    fetcher: ProviderFetch;
+    signal?: AbortSignal;
+}
+type GreynoiseActionHandler = (input: Record<string, unknown>, context: GreynoiseRuntimeContext) => Promise<unknown>;
+export declare const greynoiseActionHandlers: ProviderActionHandlers<"greynoise", GreynoiseActionHandler>;
+export {};

package/src/providers/greynoise/runtime.js

@@ -0,0 +1,71 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { encodePathSegment, isIpv4Address } from "../../core/request.js";
+import { parseProviderJsonBodyText, providerInputError, ProviderRequestError, providerUserAgent, readProviderErrorTextBody, readProviderTextBody, requiredInputString, requiredResponseRecord, runProviderRequest, withRetryAfterSeconds, } from "../provider-runtime.js";
+export const greynoiseApiBaseUrl = "https://api.greynoise.io";
+export const greynoiseActionHandlers = {
+    async lookup_ip(input, context) {
+        const ip = ipv4PathSegment(input.ip);
+        return requiredResponseRecord(await requestGreynoise({ context, ip, path: `/v3/community/${ip}` }), "GreyNoise IP lookup");
+    },
+};
+/**
+ * Accept an IPv4 address only, so a model-supplied hostname or IPv6 literal never
+ * reaches the request path: the Community endpoint serves IPv4 addresses only.
+ */
+function ipv4PathSegment(value) {
+    const ip = requiredInputString(value, "ip");
+    if (!isIpv4Address(ip)) {
+        throw providerInputError("ip must be an IPv4 address such as 8.8.8.8.");
+    }
+    return encodePathSegment(ip);
+}
+async function requestGreynoise(request) {
+    const url = new URL(`${greynoiseApiBaseUrl}${request.path}`);
+    return runProviderRequest({ label: "GreyNoise", signal: request.context.signal }, async (signal) => {
+        const response = await request.context.fetcher(url, {
+            headers: {
+                accept: "application/json",
+                "user-agent": providerUserAgent,
+            },
+            signal,
+        });
+        if (response.status === 404) {
+            const payload = parseProviderJsonBodyText(await readProviderErrorTextBody(response, "GreyNoise error response"), {
+                emptyBody: {},
+                invalidJsonMessage: "GreyNoise returned malformed JSON",
+                invalidJsonFallback: () => ({}),
+            });
+            const record = optionalRecord(payload);
+            if (record?.ip === request.ip && record.noise === false && record.riot === false)
+                return {
+                    ...record,
+                    ip: request.ip,
+                    noise: false,
+                    riot: false,
+                    message: optionalString(record.message) ?? "IP not observed scanning the internet or contained in RIOT data set.",
+                };
+            throw new ProviderRequestError(404, optionalString(record?.message) ?? "GreyNoise lookup route returned 404", payload, "provider_error");
+        }
+        if (!response.ok) {
+            throw await readGreynoiseError(response);
+        }
+        return parseProviderJsonBodyText(await readProviderTextBody(response, "GreyNoise response"), {
+            emptyBody: null,
+            invalidJsonMessage: "GreyNoise returned malformed JSON",
+        });
+    });
+}
+/**
+ * Map a GreyNoise error onto the runtime's status conventions. The Community endpoint
+ * needs no credentials, so an authorization failure is not something reconnecting can fix.
+ */
+async function readGreynoiseError(response) {
+    const payload = parseProviderJsonBodyText(await readProviderErrorTextBody(response, "GreyNoise error response"), {
+        emptyBody: {},
+        invalidJsonMessage: "GreyNoise returned malformed JSON",
+        invalidJsonFallback: () => ({}),
+    });
+    const message = optionalString(optionalRecord(payload)?.message) ?? `GreyNoise request failed with HTTP ${response.status}`;
+    const status = response.status;
+    return new ProviderRequestError(status, message, withRetryAfterSeconds(response, payload), status === 429 ? "rate_limited" : "provider_error");
+}

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

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

package/src/providers/growsurf/actions.js

@@ -0,0 +1,182 @@
+import { jsonSchema as s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const campaignId = s.nonWhitespaceString("GrowSurf program ID.");
+const participantIdOrEmail = s.nonWhitespaceString("Participant ID or email address; pass the original unencoded value.");
+const participantPath = { campaignId, participantIdOrEmail };
+const metadata = s.looseObject("Shallow custom participant metadata.", {});
+const participantOutput = s.object("Participant details, including additional GrowSurf fields.", {
+    id: s.string("Participant ID."),
+    email: s.string("Participant email address."),
+    firstName: s.nullable(s.string("Participant first name.")),
+    lastName: s.nullable(s.string("Participant last name.")),
+    referralCount: s.integer("Total referrals made by the participant."),
+    shareUrl: s.string("Referral sharing URL; omitted for unapproved affiliates."),
+    referralStatus: s.string("Referral credit status."),
+    affiliateStatus: s.nullable(s.string("Affiliate enrollment status.")),
+    metadata,
+}, { required: ["id", "email"], additionalProperties: true });
+const campaignOutput = s.object("Program details, including additional GrowSurf fields.", {
+    id: s.string("Program ID."),
+    name: s.string("Internal program name."),
+    type: s.string("Program type."),
+    status: s.string("Program status."),
+    referralCount: s.integer("Total referral count."),
+    participantCount: s.integer("Total participant count."),
+}, { required: ["id", "name"], additionalProperties: true });
+const teamOutput = s.object("Team bound to the API key.", {
+    name: s.string("Team display name."),
+    verificationStatus: s.string("Team verification state; VERIFIED is required to send participant emails."),
+    verificationRequestedAt: s.nullable(s.integer("Last verification request time in Unix milliseconds.")),
+}, { required: ["name"], additionalProperties: true });
+const commonParticipantFields = {
+    email: s.string("Participant email address.", { format: "email" }),
+    referredBy: s.string("Referrer participant ID or email address.", { maxLength: 100 }),
+    firstName: s.string("Participant first name.", { maxLength: 255 }),
+    lastName: s.string("Participant last name.", { maxLength: 255 }),
+    metadata,
+};
+const referralOutput = s.object("Referral trigger result.", {
+    success: s.boolean("Whether referral credit was awarded, scheduled, or its pending trigger cancelled."),
+    message: s.string("Additional result details, when returned."),
+}, { required: ["success"], additionalProperties: true });
+export const growsurfActions = [
+    defineProviderAction("growsurf", {
+        name: "get_team",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get the GrowSurf team bound to your API key and its email verification state.",
+        inputSchema: s.requiredObject("No input parameters are required.", {}),
+        outputSchema: teamOutput,
+    }),
+    defineProviderAction("growsurf", {
+        name: "list_campaigns",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List GrowSurf programs belonging to your API key's team. Deleted programs are excluded.",
+        inputSchema: s.requiredObject("No input parameters are required.", {}),
+        outputSchema: s.looseRequiredObject("Team programs.", {
+            campaigns: s.array("Available programs.", campaignOutput),
+        }),
+    }),
+    defineProviderAction("growsurf", {
+        name: "get_campaign",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get one GrowSurf program's configuration and totals.",
+        inputSchema: s.requiredObject("Program lookup.", { campaignId }),
+        outputSchema: campaignOutput,
+    }),
+    defineProviderAction("growsurf", {
+        name: "list_participants",
+        operationType: "read",
+        requiredScopes: [],
+        description: "List a page of GrowSurf participants. Pass nextId into the next request until null; metadata filters match all supplied values exactly.",
+        inputSchema: s.object("Participant listing filters.", {
+            campaignId,
+            nextId: s.string("Cursor from the previous page."),
+            limit: s.integer("Page size; GrowSurf defaults to 10.", { minimum: 1, maximum: 100 }),
+            metadata: {
+                ...s.object("Exact metadata filters, up to three keys.", {}, { additionalProperties: s.string("Metadata filter value.") }),
+                maxProperties: 3,
+            },
+        }, { optional: ["nextId", "limit", "metadata"] }),
+        outputSchema: s.looseRequiredObject("Participant page.", {
+            participants: s.array("Participants on this page.", participantOutput),
+            limit: s.integer("Requested page size."),
+            nextId: s.nullable(s.string("Next page cursor, or null when finished.")),
+        }),
+    }),
+    defineProviderAction("growsurf", {
+        name: "get_participant",
+        operationType: "read",
+        requiredScopes: [],
+        description: "Get a GrowSurf participant by ID or email address.",
+        inputSchema: s.requiredObject("Participant lookup.", participantPath),
+        outputSchema: participantOutput,
+    }),
+    defineProviderAction("growsurf", {
+        name: "create_participant",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Add a GrowSurf participant; an existing email returns its participant unchanged. In affiliate programs, omitted isAffiliate enrolls an approved affiliate unless a valid referredBy is supplied. Referred signups may earn Lead rewards.",
+        inputSchema: s.requiredObject("Participant creation.", {
+            campaignId,
+            participant: s.object("New participant fields.", {
+                ...commonParticipantFields,
+                isAffiliate: s.boolean("Affiliate programs only: true enrolls an approved affiliate; false creates a non-affiliate. Applies only to new participants."),
+                referralStatus: s.stringEnum("Referral credit status when referredBy resolves; omit to use program rules.", [
+                    "CREDIT_PENDING",
+                    "CREDIT_AWARDED",
+                ]),
+                ipAddress: s.string("Participant IP address, when available.", { maxLength: 255 }),
+                fingerprint: s.string("Browser identifier, when available.", { maxLength: 255 }),
+                mobileInstanceId: s.string("App-install scoped identifier supplied by a native app."),
+            }, { required: ["email"] }),
+        }),
+        outputSchema: participantOutput,
+    }),
+    defineProviderAction("growsurf", {
+        name: "update_participant",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Update a GrowSurf participant. Can suspend or ban affiliates and expire referral credit. Supplied vanityKeys replace existing aliases; omitted fields remain unchanged.",
+        inputSchema: s.requiredObject("Participant update.", {
+            ...participantPath,
+            participant: {
+                ...s.object("Participant fields to update.", {
+                    ...commonParticipantFields,
+                    referralStatus: s.stringEnum("Referral credit status.", [
+                        "CREDIT_PENDING",
+                        "CREDIT_AWARDED",
+                        "CREDIT_EXPIRED",
+                    ]),
+                    affiliateStatus: s.stringEnum("Affiliate status; APPROVED also enrolls a non-affiliate, while SUSPENDED and BANNED require an existing affiliate.", ["APPROVED", "SUSPENDED", "BANNED"]),
+                    vanityKeys: s.array("Replacement referral-code aliases.", s.string("Referral-code alias.", {
+                        minLength: 1,
+                        maxLength: 20,
+                        pattern: "^[A-Za-z0-9_-]+$",
+                    }), { maxItems: 5 }),
+                    unsubscribed: s.boolean("Whether the participant is unsubscribed from program emails."),
+                    notes: s.string("Internal participant notes, never exposed to participants.", {
+                        maxLength: 500,
+                    }),
+                }, { required: [] }),
+                minProperties: 1,
+            },
+        }),
+        outputSchema: participantOutput,
+    }),
+    defineProviderAction("growsurf", {
+        name: "delete_participant",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Delete a GrowSurf participant. Pending analytics erasure runs automatically; do not repeat deletion to complete it.",
+        inputSchema: s.requiredObject("Participant deletion.", participantPath),
+        outputSchema: s.object("Participant deletion result.", {
+            success: s.boolean("Whether participant cleanup completed."),
+            analyticsErasure: s.looseObject("Pending analytics erasure details, when returned.", {}),
+        }, { required: ["success"], additionalProperties: true }),
+    }),
+    defineProviderAction("growsurf", {
+        name: "trigger_referral",
+        operationType: "write",
+        requiredScopes: [],
+        description: "Trigger referral credit for a GrowSurf participant immediately or after a delay managed by GrowSurf. Inspect success and message for the actual outcome.",
+        inputSchema: s.object("Referral trigger input.", {
+            ...participantPath,
+            delayInDays: s.integer("Whole days to delay credit; omit for immediate credit.", {
+                minimum: 1,
+                maximum: 90,
+            }),
+        }, { optional: ["delayInDays"] }),
+        outputSchema: referralOutput,
+    }),
+    defineProviderAction("growsurf", {
+        name: "cancel_delayed_referral",
+        operationType: "destructive",
+        requiredScopes: [],
+        description: "Cancel a pending delayed GrowSurf referral trigger. Returns success false when there is no pending trigger.",
+        inputSchema: s.requiredObject("Delayed referral cancellation.", participantPath),
+        outputSchema: referralOutput,
+    }),
+];

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

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

package/src/providers/growsurf/executors.js

@@ -0,0 +1,140 @@
+import { optionalRecord, optionalRawString } from "../../core/cast.js";
+import { providerInputError, providerResponseError, defineApiKeyProviderExecutors, defineProviderProxy, mapProviderActionHandlers, requiredInputString, requiredResponseRecord, providerUserAgent, runProviderRequest, ProviderRequestError, readProviderProxyErrorMessage, withRetryAfterSeconds, } from "../provider-runtime.js";
+import { growsurfActions } from "./actions.js";
+const baseUrl = "https://api.growsurf.com/v2";
+function encodePathSegment(value) {
+    if (value === "." || value === "..") {
+        throw providerInputError("GrowSurf path identifiers cannot be dot segments");
+    }
+    return encodeURIComponent(value);
+}
+async function request({ endpoint, method, apiKey, body, query, fetcher, signal: parentSignal }) {
+    return runProviderRequest({ label: "GrowSurf", signal: parentSignal }, async (signal) => {
+        const url = new URL(`${baseUrl}${endpoint}`);
+        if (query)
+            url.search = query.toString();
+        const headers = new Headers({
+            authorization: `Bearer ${apiKey}`,
+            accept: "application/json",
+            "user-agent": providerUserAgent,
+        });
+        if (body !== undefined)
+            headers.set("content-type", "application/json");
+        const response = await fetcher(url, {
+            method,
+            headers,
+            body: body === undefined ? undefined : JSON.stringify(body),
+            signal,
+        });
+        const text = await response.text();
+        let payload = undefined;
+        try {
+            payload = JSON.parse(text);
+        }
+        catch {
+            payload = undefined;
+        }
+        if (!response.ok) {
+            const error = optionalRecord(payload);
+            const code = optionalRawString(error?.code);
+            const detail = optionalRawString(error?.message) ?? optionalRawString(error?.name) ?? text;
+            const message = [code, detail.trim() || `GrowSurf request failed with status ${response.status}`]
+                .filter(Boolean)
+                .join(": ");
+            throw new ProviderRequestError(response.status, message.replaceAll(apiKey, "[REDACTED]"), undefined, response.status === 429 ? "rate_limited" : "provider_error");
+        }
+        return requiredResponseRecord(payload, "GrowSurf response");
+    });
+}
+const handlers = mapProviderActionHandlers("growsurf", growsurfActions, (action) => async (values, context) => {
+    let endpoint;
+    let method = "GET";
+    let body = undefined;
+    let query = undefined;
+    if (action.name === "get_team") {
+        endpoint = "/team";
+    }
+    else if (action.name === "list_campaigns") {
+        endpoint = "/campaigns";
+    }
+    else {
+        endpoint = `/campaign/${encodePathSegment(requiredInputString(values.campaignId, "campaignId"))}`;
+        switch (action.name) {
+            case "get_campaign":
+                break;
+            case "list_participants": {
+                endpoint += "/participants";
+                query = new URLSearchParams();
+                if (values.nextId !== undefined)
+                    query.set("nextId", String(values.nextId));
+                if (values.limit !== undefined)
+                    query.set("limit", String(values.limit));
+                for (const [key, value] of Object.entries(optionalRecord(values.metadata) ?? {})) {
+                    query.set(`metadata[${key}]`, String(value));
+                }
+                break;
+            }
+            case "create_participant":
+                endpoint += "/participant";
+                method = "POST";
+                body = values.participant;
+                break;
+            default:
+                endpoint += `/participant/${encodePathSegment(requiredInputString(values.participantIdOrEmail, "participantIdOrEmail"))}`;
+                if (action.name === "update_participant") {
+                    method = "POST";
+                    body = values.participant;
+                }
+                else if (action.name === "delete_participant") {
+                    method = "DELETE";
+                }
+                else if (action.name === "trigger_referral") {
+                    endpoint += "/ref";
+                    method = "POST";
+                    body = { delayInDays: values.delayInDays };
+                }
+                else if (action.name === "cancel_delayed_referral") {
+                    endpoint += "/ref";
+                    method = "DELETE";
+                }
+        }
+    }
+    return request({ ...context, endpoint, method, body, query });
+});
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        const team = await request({
+            endpoint: "/team",
+            method: "GET",
+            apiKey: requiredInputString(input.apiKey, "API Key"),
+            fetcher,
+            signal,
+        });
+        const name = optionalRawString(team.name);
+        if (!name?.trim()) {
+            throw providerResponseError("GrowSurf team response is missing name");
+        }
+        return {
+            profile: { displayName: name },
+            grantedScopes: [],
+            metadata: { apiBaseUrl: baseUrl, validationEndpoint: "/team" },
+        };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("growsurf", handlers, {
+    skipDnsValidation: true,
+});
+export const proxy = defineProviderProxy({
+    service: "growsurf",
+    baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    skipDnsValidation: true,
+    async readError(response) {
+        return new ProviderRequestError(response.status, await readProviderProxyErrorMessage(response, `Provider request failed with HTTP ${response.status}`), withRetryAfterSeconds(response), response.status === 429 ? "rate_limited" : "provider_error");
+    },
+    customizeRequest({ headers }) {
+        for (const [name, value] of Object.entries({ accept: "application/json", "user-agent": providerUserAgent }))
+            if (!headers.has(name))
+                headers.set(name, value);
+    },
+});