@wfgraph/plugins 0.0.1

package/LICENSE

@@ -0,0 +1,14 @@
+Copyright 2025 Vercel, Inc.
+Copyright 2026 Alan Cohen
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

package/dist/client-BEcFnbOB.js

@@ -0,0 +1,34 @@
+import { getErrorMessage } from "@wfgraph/core/plugin";
+import { createClerkClient } from "@clerk/backend";
+//#region src/clerk/client.ts
+function createClerkBackendClient(secretKey) {
+	return createClerkClient({ secretKey });
+}
+function toClerkApiUser(user) {
+	return {
+		id: user.id,
+		first_name: user.firstName,
+		last_name: user.lastName,
+		email_addresses: user.emailAddresses.map((email) => ({
+			id: email.id,
+			email_address: email.emailAddress
+		})),
+		primary_email_address_id: user.primaryEmailAddressId,
+		public_metadata: user.publicMetadata,
+		private_metadata: user.privateMetadata,
+		created_at: user.createdAt,
+		updated_at: user.updatedAt
+	};
+}
+function getClerkApiErrorMessage(error) {
+	if (error && typeof error === "object") {
+		const clerkError = error;
+		const firstError = Array.isArray(clerkError.errors) ? clerkError.errors[0] : void 0;
+		if (firstError && typeof firstError.message === "string" && firstError.message.length > 0) return firstError.message;
+		if (typeof clerkError.status === "number") return String(clerkError.status);
+		if (typeof clerkError.message === "string" && clerkError.message.length > 0) return clerkError.message;
+	}
+	return getErrorMessage(error);
+}
+//#endregion
+export { getClerkApiErrorMessage as n, toClerkApiUser as r, createClerkBackendClient as t };

package/dist/client-C2NIQxhb.js

@@ -0,0 +1,64 @@
+import { callExternal, parsePayload } from "@wfgraph/core/plugin";
+import { Schema } from "effect";
+//#region src/resend/client.ts
+const RESEND_API_BASE = "https://api.resend.com";
+/** Resend's error body. `name` is the machine-readable slug. */
+const resendErrorSchema = Schema.Struct({
+	statusCode: Schema.optionalKey(Schema.Finite),
+	name: Schema.optionalKey(Schema.String),
+	message: Schema.optionalKey(Schema.String)
+});
+const sentEmailSchema = Schema.Struct({ id: Schema.String });
+/**
+* Resend's error body, for a caller that reports more than the message.
+*
+* The connection test is that caller: a send-only key answers
+* `restricted_api_key` on the domains endpoint, which confirms the key works,
+* and only the slug says so.
+*/
+function readResendError(payload) {
+	return parsePayload(payload, resendErrorSchema);
+}
+/**
+* What Resend said, in one sentence a person reads.
+*
+* A refusal carries Resend's own message when its error body is the documented
+* shape and the bare status when it is not. A 2xx whose body is not the
+* documented resource says so, because reporting success there would tell the
+* run an email went out and leave nothing to look it up by.
+*/
+function describeResendFailure(error) {
+	if (error._tag === "ExternalUnreachable") return error.message;
+	if (error._tag === "ExternalUnreadable") return `Resend answered ${error.status} with an unrecognized body`;
+	return readResendError(error.payload)?.message ?? `HTTP ${error.status}`;
+}
+function requestResend(apiKey, path, schema, init) {
+	return callExternal({
+		system: "Resend",
+		url: `${RESEND_API_BASE}${path}`,
+		method: init.method,
+		headers: { authorization: `Bearer ${apiKey}` },
+		body: init.jsonBody === void 0 ? void 0 : {
+			kind: "json",
+			value: init.jsonBody
+		},
+		idempotencyKey: init.idempotencyKey,
+		schema
+	});
+}
+function sendResendEmail(apiKey, payload, idempotencyKey) {
+	return requestResend(apiKey, "/emails", sentEmailSchema, {
+		method: "POST",
+		jsonBody: payload,
+		idempotencyKey
+	});
+}
+/**
+* Listing domains is a read-only call any valid key can make, which makes it the
+* check that says whether a key works without sending anything.
+*/
+function listResendDomains(apiKey) {
+	return requestResend(apiKey, "/domains", Schema.Unknown, { method: "GET" });
+}
+//#endregion
+export { sendResendEmail as i, listResendDomains as n, readResendError as r, describeResendFailure as t };

package/dist/client-DDDCNLId.js

@@ -0,0 +1,58 @@
+import { callExternal, parsePayload } from "@wfgraph/core/plugin";
+import { Schema } from "effect";
+//#region src/slack/client.ts
+const SLACK_API_BASE = "https://slack.com/api";
+/**
+* Slack answers every call with this envelope, on success and failure alike.
+* The fields a caller actually wants sit beside these two, which is why the
+* caller's own schema reads the same payload again below.
+*/
+const slackEnvelopeSchema = Schema.Struct({
+	ok: Schema.Boolean,
+	error: Schema.optionalKey(Schema.String)
+});
+/**
+* Slack's own error slug out of a refusal, or undefined when the refusal did
+* not come from Slack.
+*
+* A refusal that does not read as a Slack envelope, or reads as one that says
+* `ok: true`, came from something standing in front of the API, so its status
+* is all there is to report. A caller that distinguishes the two -- the
+* connection test does, because it words them differently -- asks here.
+*/
+function readSlackError(payload) {
+	const envelope = parsePayload(payload, slackEnvelopeSchema);
+	if (envelope === void 0 || envelope.ok) return;
+	return envelope.error ?? "unknown_error";
+}
+/** What Slack said, in one sentence a person reads. */
+function describeSlackFailure(error) {
+	if (error._tag === "ExternalUnreachable") return error.message;
+	if (error._tag === "ExternalUnreadable") return `HTTP ${error.status}`;
+	return readSlackError(error.payload) ?? `HTTP ${error.status}`;
+}
+/**
+* `options` carries the arguments Slack's method takes and whether repeating the
+* call is safe, in one bag so that a caller wanting the second does not have to
+* name the first.
+*/
+function callSlack(token, method, schema, options = {}) {
+	return callExternal({
+		system: "Slack",
+		url: `${SLACK_API_BASE}/${method}`,
+		method: "POST",
+		headers: {
+			authorization: `Bearer ${token}`,
+			"content-type": "application/json; charset=utf-8"
+		},
+		body: {
+			kind: "json",
+			value: options.body ?? {}
+		},
+		schema,
+		refusedInBody: (payload) => parsePayload(payload, slackEnvelopeSchema)?.ok !== true,
+		safeToRepeat: options.safeToRepeat
+	});
+}
+//#endregion
+export { describeSlackFailure as n, readSlackError as r, callSlack as t };

package/dist/client-DJGI9f53.js

@@ -0,0 +1,73 @@
+import { callExternal, parsePayload } from "@wfgraph/core/plugin";
+import { Schema } from "effect";
+import { omitBy } from "es-toolkit/object";
+import { isNil } from "es-toolkit/predicate";
+//#region src/twilio/client.ts
+const TWILIO_API_BASE = "https://api.twilio.com/2010-04-01";
+/** Twilio's error body, the same shape on every endpoint. */
+const twilioErrorSchema = Schema.Struct({
+	code: Schema.optionalKey(Schema.Finite),
+	message: Schema.optionalKey(Schema.String),
+	more_info: Schema.optionalKey(Schema.String)
+});
+/** The Message resource, as much of it as this plugin reads. */
+const twilioMessageSchema = Schema.Struct({
+	sid: Schema.String,
+	status: Schema.String,
+	to: Schema.String,
+	from: Schema.optionalKey(Schema.NullishOr(Schema.String)),
+	messaging_service_sid: Schema.optionalKey(Schema.NullishOr(Schema.String))
+});
+/**
+* What Twilio said, in one sentence a person reads.
+*
+* A refusal carries Twilio's own message when its error body is the documented
+* shape and the bare status when it is not, which is what something standing in
+* front of the API answers with. A 2xx whose body is not the resource says so,
+* because reporting success there would hand the run an empty message SID.
+*/
+function describeTwilioFailure(error) {
+	if (error._tag === "ExternalUnreachable") return error.message;
+	if (error._tag === "ExternalUnreadable") return `Twilio answered ${error.status} with an unrecognized body`;
+	return readTwilioError(error.payload)?.message ?? `HTTP ${error.status}`;
+}
+/** Twilio's error body, for a caller that reports more than the message. */
+function readTwilioError(payload) {
+	return parsePayload(payload, twilioErrorSchema);
+}
+function toBasicAuth(accountSid, authToken) {
+	return `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`;
+}
+function requestTwilio(credentials, path, schema, init) {
+	return callExternal({
+		system: "Twilio",
+		url: `${TWILIO_API_BASE}${path}`,
+		method: init.method,
+		headers: { authorization: toBasicAuth(credentials.accountSid, credentials.authToken) },
+		body: init.body === void 0 ? void 0 : {
+			kind: "form",
+			value: init.body
+		},
+		schema
+	});
+}
+/**
+* Sending is the one call here that a repeat could do twice, and Twilio's
+* Message resource takes no idempotency key, so it is not retried: a send that
+* timed out on the way back stays sent once.
+*/
+function createTwilioMessage(credentials, parameters) {
+	const { MediaUrl, ...scalars } = parameters;
+	const body = new URLSearchParams(omitBy(scalars, isNil));
+	for (const mediaUrl of MediaUrl ?? []) body.append("MediaUrl", mediaUrl);
+	return requestTwilio(credentials, `/Accounts/${encodeURIComponent(credentials.accountSid)}/Messages.json`, twilioMessageSchema, {
+		method: "POST",
+		body
+	});
+}
+/** Reading the account back is Twilio's cheapest credential check. */
+function fetchTwilioAccount(credentials) {
+	return requestTwilio(credentials, `/Accounts/${encodeURIComponent(credentials.accountSid)}.json`, Schema.Struct({ sid: Schema.String }), { method: "GET" });
+}
+//#endregion
+export { readTwilioError as i, describeTwilioFailure as n, fetchTwilioAccount as r, createTwilioMessage as t };

package/dist/client-DkPUX0ps.js

@@ -0,0 +1,50 @@
+import { StepFailure, getErrorMessage } from "@wfgraph/core/plugin";
+import { Effect } from "effect";
+import { Acuity, AcuityError } from "@fountain-bio/acuity";
+//#region src/acuity/client.ts
+/** Production SDK construction from stored credentials. */
+function createAcuitySdk(userId, apiKey) {
+	return new Acuity({
+		userId,
+		apiKey
+	});
+}
+/**
+* The Acuity SDK, built from the step's own credentials, or the failure that
+* says which of them is missing.
+*
+* It takes the handler's whole bag rather than the credentials, so fetching them
+* is part of the one line every handler opens with. Every step starts here, which
+* is what makes the check on them written once and reported the same way.
+*
+* A store that could not be read is passed on rather than turned into a
+* `StepFailure`: that failure is the one a step is retried for.
+*/
+function createAcuityClient(bag, createSdk) {
+	return Effect.flatMap(bag.credentials, (credentials) => {
+		const userId = credentials.ACUITY_USER_ID?.trim();
+		const apiKey = credentials.ACUITY_API_KEY?.trim();
+		return userId && apiKey ? Effect.succeed(createSdk(userId, apiKey)) : Effect.fail(new StepFailure({ message: "ACUITY_USER_ID and ACUITY_API_KEY are required. Add them in Project Integrations." }));
+	});
+}
+/**
+* One call to Acuity, with the sentence that says what went wrong if it did.
+*
+* The SDK throws, and what it throws is an `AcuityError` carrying the API's own
+* message when Acuity answered and something more general when it did not, so
+* the fallback each step passes names the thing that step was doing.
+*/
+function callAcuity(fallback, call) {
+	return Effect.tryPromise({
+		try: call,
+		catch: (error) => new StepFailure({ message: getAcuityErrorMessage(error, fallback) })
+	});
+}
+function getAcuityErrorMessage(error, fallback) {
+	if (error instanceof AcuityError) return error.message;
+	const message = getErrorMessage(error);
+	if (message && message !== "Unknown error") return message;
+	return fallback;
+}
+//#endregion
+export { getAcuityErrorMessage as i, createAcuityClient as n, createAcuitySdk as r, callAcuity as t };

package/dist/errors-C4i6-DQE.js

@@ -0,0 +1,77 @@
+import { getErrorMessage } from "@wfgraph/core/plugin";
+import { Option, Schema } from "effect";
+import { LinearError, parseLinearError } from "@linear/sdk";
+//#region src/linear/errors.ts
+/**
+* The error payload Linear's `parseLinearError` reads: the GraphQL request that
+* failed, the response that came back with its status and GraphQL errors, and a
+* top-level message. Anything caught while talking to Linear arrives as `unknown`,
+* so this schema is the boundary that decides whether Linear can classify it.
+*
+* Every level stays open, because Linear reads fields this schema does not name
+* (`response.data`, `response.headers`) and the validated value is handed on to
+* Linear whole. The named fields are the ones Linear reads unguarded: a `message`
+* that is not a string, or a `response.errors` that is not a list of objects,
+* makes Linear's own parsing throw. `onExcessProperty: "preserve"` in the decode
+* below is what keeps the unnamed fields, at every level, on the value that comes
+* back; the default strips them.
+*
+* Fields are described as the API sends them. Linear's LinearErrorRaw types both
+* the per-error `message` and `extensions.type` as its LinearErrorType enum, while
+* the wire carries readable text ("Authentication required") and a lowercase
+* phrase ("authentication error") that Linear maps back to the enum itself.
+*/
+const linearGraphqlErrorSchema = Schema.Struct({
+	message: Schema.optionalKey(Schema.String),
+	path: Schema.optionalKey(Schema.Array(Schema.String)),
+	extensions: Schema.optionalKey(Schema.Struct({
+		type: Schema.optionalKey(Schema.String),
+		userError: Schema.optionalKey(Schema.Boolean),
+		userPresentableMessage: Schema.optionalKey(Schema.String)
+	}))
+});
+const linearErrorRawSchema = Schema.Struct({
+	name: Schema.optionalKey(Schema.String),
+	message: Schema.optionalKey(Schema.String),
+	request: Schema.optionalKey(Schema.Struct({
+		query: Schema.optionalKey(Schema.String),
+		variables: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown))
+	})),
+	response: Schema.optionalKey(Schema.Struct({
+		status: Schema.optionalKey(Schema.Finite),
+		error: Schema.optionalKey(Schema.String),
+		errors: Schema.optionalKey(Schema.Array(linearGraphqlErrorSchema))
+	}))
+});
+const readLinearErrorRaw = Schema.decodeUnknownOption(linearErrorRawSchema, { onExcessProperty: "preserve" });
+/**
+* Normalizes anything thrown while talking to Linear into a LinearError, which is
+* what the steps read an error type and a message from. The SDK wraps its own
+* failures, so the remaining cases are a raw error payload from a GraphQL client,
+* a plain Error, and a bare string.
+*/
+function toLinearError(error) {
+	if (error instanceof LinearError) return error;
+	const raw = Option.getOrUndefined(readLinearErrorRaw(error));
+	if (raw) return parseLinearError(raw);
+	if (error instanceof Error) return parseLinearError({
+		name: error.name,
+		message: error.message
+	});
+	if (typeof error === "string") return parseLinearError({ message: error });
+	return parseLinearError();
+}
+/**
+* What Linear said, in the one sentence a step's failure carries.
+*
+* The GraphQL error is the specific one -- "Entity not found: Issue" -- and the
+* wrapper's message is the general one, so the first that says anything wins.
+* A throw Linear cannot classify at all falls through to whatever the thrown
+* value had to say for itself.
+*/
+function describeLinearFailure(error) {
+	const linearError = toLinearError(error);
+	return linearError.errors?.[0]?.message || linearError.message || getErrorMessage(error);
+}
+//#endregion
+export { toLinearError as n, describeLinearFailure as t };