@oomol-lab/open-connector 1.9.1 → 1.9.2

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

@@ -0,0 +1,113 @@
+import { optionalRecord, optionalString } from "../../core/cast.js";
+import { downloadUploadSource, requiredResponseRecord, requiredInputString, isAbortLikeError, runProviderRequest, ProviderRequestError, providerInputError, providerResponseError, defineApiKeyProviderExecutors, defineProviderProxy, } from "../provider-runtime.js";
+import { saperlyActions } from "./actions.js";
+import { saperlyEndpointByName } from "./actions.js";
+const baseUrl = "https://api.saperly.com";
+async function request(endpoint, input, apiKey, fetcher, parentSignal) {
+    let pathname = endpoint.path;
+    for (const key of endpoint.pathKeys) {
+        const value = requiredInputString(input[key], key);
+        if (value === "." || value === "..") {
+            throw providerInputError(`${key} cannot be a dot path segment`);
+        }
+        pathname = pathname.replace(`{${key}}`, encodeURIComponent(value));
+    }
+    const url = new URL(pathname, baseUrl);
+    for (const key of endpoint.queryKeys) {
+        if (input[key] != null)
+            url.searchParams.set(key, String(input[key]));
+    }
+    const headers = new Headers({ authorization: `Bearer ${apiKey}`, accept: "application/json" });
+    const idempotencyKey = optionalString(input.idempotencyKey);
+    if (idempotencyKey)
+        headers.set("Idempotency-Key", idempotencyKey);
+    let body;
+    if (endpoint.name === "create_custom_voice") {
+        const audioUrl = requiredInputString(input.audioUrl, "audioUrl");
+        const source = await downloadUploadSource({ url: audioUrl, fetcher, fieldName: "audioUrl", signal: parentSignal });
+        const form = new FormData();
+        for (const key of ["name", "language", "gender"]) {
+            form.set(key, requiredInputString(input[key], key));
+        }
+        const fileName = optionalString(input.fileName) ?? new URL(audioUrl).pathname.split("/").pop() ?? "sample";
+        form.set("audio", new Blob([new Uint8Array(source.bytes)], {
+            type: source.contentType ?? "application/octet-stream",
+        }), fileName || "sample");
+        body = form;
+    }
+    else if (endpoint.method !== "GET") {
+        const payload = Object.fromEntries(Object.entries(input).filter(([key, value]) => key !== "idempotencyKey" &&
+            !endpoint.pathKeys.includes(key) &&
+            !endpoint.queryKeys.includes(key) &&
+            value !== undefined));
+        headers.set("content-type", "application/json");
+        body = JSON.stringify(payload);
+    }
+    return runProviderRequest({ label: "Saperly", signal: parentSignal }, async (signal) => {
+        const response = await fetcher(url, {
+            method: endpoint.method,
+            headers,
+            body,
+            signal,
+            redirect: endpoint.outputKind === "recording" ? "manual" : undefined,
+        });
+        if (endpoint.outputKind === "recording" && response.status === 302) {
+            const location = response.headers.get("location");
+            await response.body?.cancel();
+            if (!location)
+                throw providerResponseError("Saperly recording URL is missing");
+            const downloadUrl = new URL(location, url);
+            if (!["https:", "http:"].includes(downloadUrl.protocol)) {
+                throw providerResponseError("Saperly recording URL is invalid");
+            }
+            return { downloadUrl: downloadUrl.href };
+        }
+        const data = await response.json().catch((error) => {
+            if (isAbortLikeError(error))
+                throw error;
+            return undefined;
+        });
+        if (!response.ok) {
+            const error = optionalRecord(data);
+            const detail = [optionalString(error?._tag), optionalString(error?.message) ?? optionalString(error?.reason)]
+                .filter(Boolean)
+                .join(": ");
+            throw new ProviderRequestError(response.status, `Saperly request failed (${response.status})${detail ? `: ${detail}` : ""}`, undefined, "provider_error");
+        }
+        if (data === undefined)
+            throw providerResponseError("Saperly returned invalid JSON");
+        if (endpoint.outputKind === "transcript")
+            return { transcript: data };
+        if (endpoint.outputKind === "recording") {
+            throw providerResponseError("Saperly did not return a recording redirect");
+        }
+        if (endpoint.outputKind === "list") {
+            if (!Array.isArray(data))
+                throw providerResponseError("Saperly response must be an array");
+            return { items: data };
+        }
+        return requiredResponseRecord(data, "Saperly response");
+    });
+}
+async function execute(actionName, values, context) {
+    const { apiKey, fetcher } = context;
+    const endpoint = saperlyEndpointByName.get(actionName);
+    if (!endpoint)
+        throw providerInputError("Unknown Saperly action");
+    return request(endpoint, values, apiKey, fetcher, context.signal);
+}
+export const credentialValidators = {
+    async apiKey(input, { fetcher, signal }) {
+        await request(saperlyEndpointByName.get("get_usage"), {}, input.apiKey, fetcher, signal);
+        return { profile: { displayName: "Saperly API Key" }, grantedScopes: [], metadata: { apiBaseUrl: baseUrl } };
+    },
+};
+export const executors = defineApiKeyProviderExecutors("saperly", Object.fromEntries(saperlyActions.map((action) => [action.name, (values, context) => execute(action.name, values, context)])));
+export const proxy = defineProviderProxy({
+    service: "saperly",
+    baseUrl: baseUrl,
+    auth: { type: "api_key_authorization", prefix: "Bearer " },
+    customizeRequest({ headers }) {
+        headers.set("accept", "application/json");
+    },
+});

package/src/providers/saperly/schemas.d.ts

@@ -0,0 +1,33 @@
+import type { JsonSchema } from "../../core/types.ts";
+export declare const healthOutput: JsonSchema;
+export declare const listWorkspaceMembersOutput: JsonSchema;
+export declare const listWorkspaceKeysOutput: JsonSchema;
+export declare const createWorkspaceKeyOutput: JsonSchema;
+export declare const listWorkspaceWebhooksOutput: JsonSchema;
+export declare const createWorkspaceWebhookOutput: JsonSchema;
+export declare const listWebhookDeliveriesOutput: JsonSchema;
+export declare const listWorkspaceAuditEventsOutput: JsonSchema;
+export declare const revokeWorkspaceKeyOutput: JsonSchema;
+export declare const sendWorkspaceInvitationOutput: JsonSchema;
+export declare const askAssistantOutput: JsonSchema;
+export declare const listNumbersOutput: JsonSchema;
+export declare const provisionNumberOutput: JsonSchema;
+export declare const releaseNumberOutput: JsonSchema;
+export declare const listConnectionsOutput: JsonSchema;
+export declare const createConnectionOutput: JsonSchema;
+export declare const deleteConnectionOutput: JsonSchema;
+export declare const sendMessageOutput: JsonSchema;
+export declare const listMessagesOutput: JsonSchema;
+export declare const placeCallOutput: JsonSchema;
+export declare const listCallsOutput: JsonSchema;
+export declare const getRecordingOutput: JsonSchema;
+export declare const getTranscriptOutput: JsonSchema;
+export declare const listVoicesOutput: JsonSchema;
+export declare const listCustomVoicesOutput: JsonSchema;
+export declare const createCustomVoiceOutput: JsonSchema;
+export declare const listLanguagesOutput: JsonSchema;
+export declare const getUsageOutput: JsonSchema;
+export declare const listConsentOutput: JsonSchema;
+export declare const recordConsentOutput: JsonSchema;
+export declare const checkConsentOutput: JsonSchema;
+export declare const getPriceQuoteOutput: JsonSchema;