@wfgraph/plugins 3.1.1 → 4.0.0

package/README.md

@@ -1,7 +1,7 @@
 # @wfgraph/plugins
 
-The five built-in integrations for
-[Workflow Graph](https://github.com/alandotcom/wfgraph): Clerk, Linear, Resend, Slack, and
+The six built-in integrations for
+[Workflow Graph](https://github.com/alandotcom/wfgraph): Clerk, Linear, PostHog, Resend, Slack, and
 Twilio.
 
 ```bash
@@ -16,14 +16,31 @@ import { createWfGraphApp } from "@wfgraph/core";
 import { builtInIntegrations } from "@wfgraph/plugins";
 
 const wfgraph = await createWfGraphApp({
-  extensions: { integrations: builtInIntegrations /* ...events and actions */ },
+  extensions: {
+    integrations: builtInIntegrations({
+      slack: {
+        oauthClient: {
+          clientId: process.env.SLACK_CLIENT_ID,
+          clientSecret: process.env.SLACK_CLIENT_SECRET,
+        },
+      },
+    }) /* ...events and actions */,
+  },
   // ...the rest
 });
 ```
 
-Each integration is also exported by name, for a host that wants some of the five rather than
-all of them. That narrows what reaches `createWfGraphApp` rather than what the process loads,
-since this entry imports all five as values.
+Resend and PostHog include OAuth through a public client metadata document. Slack enables
+OAuth when you pass a registered Slack app client. All three retain manual credential
+entry. OAuth callback URLs also require `publicUrl` on `createWfGraphApp`.
+Resend's webhook Events use the same `publicUrl` to copy a Connection-addressed
+intake URL; add the signing secret (`RESEND_WEBHOOK_SECRET`) on that Connection.
+
+Clerk, Linear, PostHog, Resend, and Twilio are also exported as values for a host that wants
+some of the six rather than all of them. Slack is a factory because it accepts OAuth
+client configuration. Selecting individual exports narrows what reaches
+`createWfGraphApp`, not what the process loads, because this entry imports all six
+integrations.
 
 `@wfgraph/core` is a peer dependency: an integration is built against it and handed back to it,
 so the two must resolve to one copy. They are released together and always share a version.

package/dist/client-B0M2Cle4.js

@@ -0,0 +1,115 @@
+import { callExternal, parsePayload } from "@wfgraph/core/plugin";
+import { Schema } from "effect";
+/**
+* PostHog's error body, the same shape on both endpoints.
+*
+* Every field is optional because the handler depends on none of them: they
+* make the message a person reads, and a build answering something else should
+* still report its status rather than fail the decode.
+*/
+const posthogErrorSchema = Schema.Struct({
+	type: Schema.optionalKey(Schema.String),
+	code: Schema.optionalKey(Schema.String),
+	detail: Schema.optionalKey(Schema.String),
+	attr: Schema.optionalKey(Schema.NullishOr(Schema.String))
+});
+/**
+* What the capture endpoint answers.
+*
+* Cloud answers `{"status": 1}` and older self-hosted builds answer
+* `{"status": "Ok"}`, so both stand. The key is optional because nothing
+* downstream reads it -- ingestion is async, and a capture that was accepted
+* says nothing about whether the event was stored.
+*/
+const captureResponseSchema = Schema.Struct({ status: Schema.optionalKey(Schema.Union([Schema.Finite, Schema.String])) });
+/**
+* The flags body is only checked for arrival. The connection test reads
+* `result.ok`, so recording unused flag maps would describe a shape nobody
+* consults.
+*/
+const flagsResponseSchema = Schema.Unknown;
+/**
+* What PostHog said, in one sentence a person reads.
+*
+* A refusal carries PostHog's own `detail` 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.
+*/
+function describePostHogFailure(error) {
+	if (error._tag === "ExternalUnreachable") return error.message;
+	if (error._tag === "ExternalUnreadable") return `PostHog answered ${error.status} with an unrecognized body`;
+	return readPostHogError(error.payload)?.detail ?? describeCaptureStatus(error.status) ?? `HTTP ${error.status}`;
+}
+/**
+* What a refusal carrying no readable body means.
+*
+* Only the capture endpoint lands here, because a flags refusal always carries a
+* `detail`. These are the two statuses it answers a misconfigured node with: a
+* key it will not take, and an event it could not read.
+*/
+function describeCaptureStatus(status) {
+	if (status === 401) return "PostHog refused the project API key (HTTP 401)";
+	if (status === 400) return "PostHog could not read the event (HTTP 400)";
+}
+/** PostHog's error body, for a caller that reports more than the message. */
+function readPostHogError(payload) {
+	return parsePayload(payload, posthogErrorSchema);
+}
+/**
+* The host with any trailing slash taken off, so joining a path cannot produce
+* a double slash. A blank host is the US cloud, which is where a project lives
+* unless someone chose otherwise.
+*/
+function resolvePostHogHost(host) {
+	return (host?.trim() || "https://us.i.posthog.com").replace(/\/+$/, "");
+}
+/**
+* Capture one event.
+*
+* Marked `safeToRepeat` on a deterministic body: every field the dedup sort key
+* reads is fixed by the caller before the first attempt, so a retry sends bytes
+* identical to the ones that may already have arrived. PostHog collapses the
+* pair during a background merge. That is eventual rather than immediate, and
+* the trade is deliberate -- for an analytics event a duplicate that merges away
+* beats a hole in a funnel nobody can reconstruct.
+*/
+function captureEvent(connection, event) {
+	return callExternal({
+		system: "PostHog",
+		url: `${connection.host}/i/v0/e/`,
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: {
+			kind: "json",
+			value: {
+				api_key: connection.projectApiKey,
+				...event
+			}
+		},
+		schema: captureResponseSchema,
+		safeToRepeat: true
+	});
+}
+/**
+* Evaluate flags for one person, which is the cheapest call that tells a bad
+* project key from a good one. Capture cannot: ingestion is async, so it answers
+* `{"status": 1}` whatever key it was given.
+*/
+function evaluateFlags(connection, distinctId) {
+	return callExternal({
+		system: "PostHog",
+		url: `${connection.host}/flags?v=2`,
+		method: "POST",
+		headers: { "content-type": "application/json" },
+		body: {
+			kind: "json",
+			value: {
+				api_key: connection.projectApiKey,
+				distinct_id: distinctId
+			}
+		},
+		schema: flagsResponseSchema,
+		safeToRepeat: true
+	});
+}
+export { resolvePostHogHost as a, readPostHogError as i, describePostHogFailure as n, evaluateFlags as r, captureEvent as t };

package/dist/{client-BEcFnbOB.js → client-B0dhD5OA.js}

@@ -1,6 +1,6 @@
 import { getErrorMessage } from "@wfgraph/core/plugin";
 import { createClerkClient } from "@clerk/backend";
-//#region src/clerk/client.ts
+// src/clerk/client.ts
 function createClerkBackendClient(secretKey) {
 	return createClerkClient({ secretKey });
 }
@@ -30,5 +30,4 @@ function getClerkApiErrorMessage(error) {
 	}
 	return getErrorMessage(error);
 }
-//#endregion
 export { getClerkApiErrorMessage as n, toClerkApiUser as r, createClerkBackendClient as t };

package/dist/{client-DDDCNLId.js → client-BQmwEhSH.js}

@@ -1,6 +1,6 @@
 import { callExternal, parsePayload } from "@wfgraph/core/plugin";
 import { Schema } from "effect";
-//#region src/slack/client.ts
+// src/slack/client.ts
 const SLACK_API_BASE = "https://slack.com/api";
 /**
 * Slack answers every call with this envelope, on success and failure alike.
@@ -54,5 +54,4 @@ function callSlack(token, method, schema, options = {}) {
 		safeToRepeat: options.safeToRepeat
 	});
 }
-//#endregion
 export { describeSlackFailure as n, readSlackError as r, callSlack as t };

package/dist/{client-LRwmIiPU.js → client-C32OdgmT.js}

@@ -1,8 +1,8 @@
+import { t as omitUndefined } from "./omit-undefined-CnDMZgmp.js";
 import { callExternal, parsePayload } from "@wfgraph/core/plugin";
-import { omitBy } from "es-toolkit/object";
-import { isNil } from "es-toolkit/predicate";
 import { Schema } from "effect";
-//#region src/twilio/client.ts
+import { Base64 } from "effect/encoding";
+// 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({
@@ -36,7 +36,7 @@ function readTwilioError(payload) {
 	return parsePayload(payload, twilioErrorSchema);
 }
 function toBasicAuth(accountSid, authToken) {
-	return `Basic ${Buffer.from(`${accountSid}:${authToken}`).toString("base64")}`;
+	return `Basic ${Base64.encode(`${accountSid}:${authToken}`)}`;
 }
 function requestTwilio(credentials, path, schema, init) {
 	return callExternal({
@@ -58,7 +58,7 @@ function requestTwilio(credentials, path, schema, init) {
 */
 function createTwilioMessage(credentials, parameters) {
 	const { MediaUrl, ...scalars } = parameters;
-	const body = new URLSearchParams(omitBy(scalars, isNil));
+	const body = new URLSearchParams(omitUndefined(scalars));
 	for (const mediaUrl of MediaUrl ?? []) body.append("MediaUrl", mediaUrl);
 	return requestTwilio(credentials, `/Accounts/${encodeURIComponent(credentials.accountSid)}/Messages.json`, twilioMessageSchema, {
 		method: "POST",
@@ -69,5 +69,4 @@ function createTwilioMessage(credentials, parameters) {
 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-D3ALurAR.js

@@ -0,0 +1,167 @@
+import { callExternal, parsePayload } from "@wfgraph/core/plugin";
+import { Effect, Schema } from "effect";
+// 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 });
+/** The fields the Find Email action reads from Resend's retrieve response. */
+const resendEmailSchema = Schema.Struct({
+	id: Schema.String,
+	message_id: Schema.String,
+	from: Schema.String,
+	to: Schema.Array(Schema.String),
+	cc: Schema.NullOr(Schema.Array(Schema.String)),
+	bcc: Schema.NullOr(Schema.Array(Schema.String)),
+	reply_to: Schema.NullOr(Schema.Array(Schema.String)),
+	subject: Schema.String,
+	html: Schema.NullOr(Schema.String),
+	text: Schema.NullOr(Schema.String),
+	created_at: Schema.DateFromString,
+	last_event: Schema.String,
+	scheduled_at: Schema.NullOr(Schema.DateFromString),
+	tags: Schema.optionalKey(Schema.Array(Schema.Struct({
+		name: Schema.String,
+		value: 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);
+}
+function classifyResendFailure(error) {
+	if (error._tag === "ExternalUnreachable") return "unreachable";
+	const body = error._tag === "ExternalRejected" ? readResendError(error.payload) : void 0;
+	const status = body?.statusCode ?? error.status;
+	if (body?.name === "invalid_permission" && status === 403) return "insufficient_scope";
+	if (body?.name === "restricted_api_key") return status === 403 ? "key_unusable" : "send_only_key";
+	if (body?.name === "suspended_api_key" || body?.name === "email_above_quota") return "key_unusable";
+	return "refused";
+}
+/**
+* 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
+	});
+}
+/**
+* Resend's template shapes, described as the wire sends them rather than as the
+* SDK types them. Only what a caller reads is required; the rest is tolerant,
+* because a field this plugin ignores must not fail the decode.
+*/
+const resendTemplateSummarySchema = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	status: Schema.optionalKey(Schema.NullOr(Schema.String))
+});
+const resendTemplateListSchema = Schema.Struct({
+	data: Schema.Array(resendTemplateSummarySchema),
+	has_more: Schema.optionalKey(Schema.NullOr(Schema.Boolean))
+});
+const resendTemplateVariableSchema = Schema.Struct({
+	key: Schema.String,
+	type: Schema.optionalKey(Schema.NullOr(Schema.String)),
+	fallback_value: Schema.optionalKey(Schema.NullOr(Schema.String))
+});
+/** Only the retrieve endpoint carries `variables`; the list endpoint does not. */
+const resendTemplateSchema = Schema.Struct({
+	id: Schema.String,
+	name: Schema.String,
+	status: Schema.optionalKey(Schema.NullOr(Schema.String)),
+	variables: Schema.optionalKey(Schema.NullOr(Schema.Array(resendTemplateVariableSchema)))
+});
+/** Resend's own maximum, so a page never asks for more than it will answer. */
+const TEMPLATE_PAGE_SIZE = 100;
+/**
+* How many pages a listing follows before it gives up.
+*
+* Each page carries `callExternal`'s own per-attempt timeout and retry schedule,
+* so a page is worth tens of seconds in the worst case and this is the number a
+* config panel can wait on. Reaching the bound is reported rather than passed
+* off as the whole list: a dropdown quietly missing the template someone wants,
+* with no way to type it either, is worse than saying the list is too long.
+*/
+const TEMPLATE_PAGE_LIMIT = 3;
+function listResendTemplatePage(apiKey, after) {
+	const query = new URLSearchParams({ limit: String(TEMPLATE_PAGE_SIZE) });
+	if (after) query.set("after", after);
+	return requestResend(apiKey, `/templates?${query.toString()}`, resendTemplateListSchema, { method: "GET" });
+}
+/**
+* Every template the account holds, or a refusal when there are more than the
+* bound above will fetch.
+*/
+function listResendTemplates(apiKey) {
+	return Effect.gen(function* () {
+		const templates = [];
+		let after;
+		for (let page = 0; page < TEMPLATE_PAGE_LIMIT; page += 1) {
+			const answer = yield* listResendTemplatePage(apiKey, after);
+			templates.push(...answer.data);
+			const last = answer.data.at(-1);
+			if (!answer.has_more || !last) return {
+				templates,
+				reachedPageLimit: false
+			};
+			after = last.id;
+		}
+		return {
+			templates,
+			reachedPageLimit: true
+		};
+	});
+}
+/** One template, with the variables only this endpoint carries. */
+function getResendTemplate(apiKey, idOrAlias) {
+	return requestResend(apiKey, `/templates/${encodeURIComponent(idOrAlias)}`, resendTemplateSchema, { method: "GET" });
+}
+function sendResendEmail(apiKey, payload, idempotencyKey) {
+	return requestResend(apiKey, "/emails", sentEmailSchema, {
+		method: "POST",
+		jsonBody: payload,
+		idempotencyKey
+	});
+}
+/** Retrieve one sent email by its Resend email ID. */
+function getResendEmail(apiKey, emailId) {
+	return requestResend(apiKey, `/emails/${encodeURIComponent(emailId)}`, resendEmailSchema, { method: "GET" });
+}
+/**
+* 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" });
+}
+export { listResendDomains as a, sendResendEmail as c, getResendTemplate as i, describeResendFailure as n, listResendTemplates as o, getResendEmail as r, readResendError as s, classifyResendFailure as t };

package/dist/config-options-BgSb_XqZ.js

@@ -0,0 +1,101 @@
+import { i as getResendTemplate, n as describeResendFailure, o as listResendTemplates, t as classifyResendFailure } from "./client-D3ALurAR.js";
+import { t as omitUndefined } from "./omit-undefined-CnDMZgmp.js";
+import { callExternalAsync } from "@wfgraph/core/plugin";
+// src/resend/config-options.ts
+/**
+* What the Send Email node's template fields are filled with.
+*
+* A Promise at its edge for the reason `test.ts` is one: core calls these over a
+* Promise, so this is where the effect is run and the transport provided.
+*
+* Which Resend refusal means what is `client.ts`'s to say, because the
+* connection test asks the same question of the same account and the two must
+* not drift.
+*/
+/** Resend's own maximum, so a template can declare no more inputs than it has. */
+const MAX_TEMPLATE_VARIABLES = 50;
+const NO_API_KEY = {
+	status: "unavailable",
+	reason: "not_permitted",
+	message: "This Resend connection has no API key. Reconnect it."
+};
+/**
+* What a refusal means for this field.
+*
+* `not_permitted` is the only reason the editor offers as something to act on,
+* so it is spent on the two cases where acting on the connection is the fix.
+*/
+function describeUnavailable(failure) {
+	switch (classifyResendFailure(failure)) {
+		case "unreachable": return {
+			status: "unavailable",
+			reason: "unreachable",
+			message: describeResendFailure(failure)
+		};
+		case "send_only_key":
+		case "insufficient_scope": return {
+			status: "unavailable",
+			reason: "not_permitted",
+			message: "This Resend connection can only send email. Reconnect it and choose full access to pick a template."
+		};
+		case "key_unusable": return {
+			status: "unavailable",
+			reason: "not_permitted",
+			message: `This Resend connection is no longer usable: ${describeResendFailure(failure)}`
+		};
+		default: return {
+			status: "unavailable",
+			reason: "refused",
+			message: describeResendFailure(failure)
+		};
+	}
+}
+/** Every template the account holds, drafts included and labelled as such. */
+async function resendTemplateOptions(credentials) {
+	const apiKey = credentials.RESEND_API_KEY;
+	if (!apiKey) return NO_API_KEY;
+	const result = await callExternalAsync(listResendTemplates(apiKey), (error) => error);
+	if (!result.ok) return describeUnavailable(result.failure);
+	if (result.data.reachedPageLimit) return {
+		status: "unavailable",
+		reason: "refused",
+		message: "This account holds more Resend templates than this list can load. Enter the template id instead."
+	};
+	return {
+		status: "options",
+		options: result.data.templates.map((template) => ({
+			value: template.id,
+			label: template.status === "draft" ? `${template.name} (draft)` : template.name
+		}))
+	};
+}
+/**
+* One input per variable the chosen template declares.
+*
+* The id is sent as the builder gave it. Resend's retrieve endpoint takes an
+* alias as readily as an id, `encodeURIComponent` is what makes the path safe,
+* and Resend's own "Template not found" is a better sentence than a shape check
+* that would refuse the aliases people actually write.
+*/
+async function resendTemplateVariableFields(credentials, request) {
+	const apiKey = credentials.RESEND_API_KEY;
+	const templateId = request.parameters.emailTemplateId;
+	if (!templateId) return {
+		status: "fields",
+		fields: []
+	};
+	if (!apiKey) return NO_API_KEY;
+	const result = await callExternalAsync(getResendTemplate(apiKey, templateId), (error) => error);
+	if (!result.ok) return describeUnavailable(result.failure);
+	return {
+		status: "fields",
+		fields: (result.data.variables ?? []).slice(0, MAX_TEMPLATE_VARIABLES).map((variable) => omitUndefined({
+			key: variable.key,
+			label: variable.key,
+			required: variable.fallback_value == null ? true : void 0,
+			defaultValue: variable.fallback_value ?? void 0,
+			type: variable.type === "number" ? "number" : void 0
+		}))
+	};
+}
+export { resendTemplateOptions, resendTemplateVariableFields };

package/dist/{errors-C4i6-DQE.js → errors-DQPf9k4I.js}

@@ -1,7 +1,7 @@
 import { getErrorMessage } from "@wfgraph/core/plugin";
 import { Option, Schema } from "effect";
 import { LinearError, parseLinearError } from "@linear/sdk";
-//#region src/linear/errors.ts
+// 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
@@ -12,38 +12,46 @@ import { LinearError, parseLinearError } from "@linear/sdk";
 * (`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.
+* makes Linear's own parsing throw. Each object uses `Schema.StructWithRest` so
+* the unnamed fields survive at every level; a closed struct would strip 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({
+const unknownFields = [Schema.Record(Schema.String, Schema.Unknown)];
+const linearErrorExtensionSchema = Schema.StructWithRest(Schema.Struct({
+	type: Schema.optionalKey(Schema.String),
+	userError: Schema.optionalKey(Schema.Boolean),
+	userPresentableMessage: Schema.optionalKey(Schema.String)
+}), unknownFields);
+const linearGraphqlErrorSchema = Schema.StructWithRest(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({
+	extensions: Schema.optionalKey(linearErrorExtensionSchema)
+}), unknownFields);
+const linearRequestSchema = Schema.StructWithRest(Schema.Struct({
+	query: Schema.optionalKey(Schema.String),
+	variables: Schema.optionalKey(Schema.Record(Schema.String, Schema.Unknown))
+}), unknownFields);
+const linearResponseSchema = Schema.StructWithRest(Schema.Struct({
+	status: Schema.optionalKey(Schema.Finite),
+	error: Schema.optionalKey(Schema.String),
+	errors: Schema.optionalKey(Schema.Array(linearGraphqlErrorSchema))
+}), unknownFields);
+const linearErrorRawSchema = Schema.StructWithRest(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" });
+	request: Schema.optionalKey(linearRequestSchema),
+	response: Schema.optionalKey(linearResponseSchema)
+}), unknownFields);
+const decodeLinearErrorRaw = Schema.decodeUnknownOption(linearErrorRawSchema);
+function readLinearErrorRaw(input) {
+	if (typeof input !== "object" || input === null) return decodeLinearErrorRaw(input);
+	const ownProperties = Object.fromEntries(Object.getOwnPropertyNames(input).map((key) => [key, Reflect.get(input, key)]));
+	return decodeLinearErrorRaw(ownProperties);
+}
 /**
 * 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
@@ -73,5 +81,4 @@ function describeLinearFailure(error) {
 	const linearError = toLinearError(error);
 	return linearError.errors?.[0]?.message || linearError.message || getErrorMessage(error);
 }
-//#endregion
 export { toLinearError as n, describeLinearFailure as t };