@gitkraken/core-gitlens 0.5.114 → 0.5.116

package/src/plus/integrations/providers/jira.ts

@@ -10,7 +10,7 @@ import type { ProviderAuthenticationSession } from '../authentication/models.js'
 import { toTokenWithInfo } from '../authentication/models.js';
 import { throwIfCallerContractError, toCollectionScopeFailure } from '../collectionMetadata.js';
 import { IssuesCloudHostIntegrationId } from '../constants.js';
-import type { IssuesForProjectOptions } from '../models/issueReads.js';
+import type { IssuesForProjectOptions, ProjectIssuesDrain } from '../models/issueReads.js';
 import { IssuesIntegration } from '../models/issuesIntegration.js';
 import type { ProviderApiCollectionResult, ProviderIssue } from './models.js';
 import { IssueFilter, providersMetadata, toAccount, toIssueShape } from './models.js';
@@ -20,6 +20,12 @@ const metadata = providersMetadata[IssuesCloudHostIntegrationId.Jira];
 const authProvider = Object.freeze({ id: metadata.id, scopes: metadata.scopes });
 const maxPagesPerRequest = 10;
 
+type JiraProjectIssuesDrain<T> = {
+	issues: T[];
+	status: 'complete' | 'backstop' | 'incomplete';
+	metadata?: CollectionMetadata;
+};
+
 export type JiraBaseDescriptor = IssueResourceDescriptor;
 
 export interface JiraOrganizationDescriptor extends JiraBaseDescriptor {
@@ -244,16 +250,11 @@ export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegratio
 		session: ProviderAuthenticationSession,
 		project: JiraProjectDescriptor,
 		options?: IssuesForProjectOptions,
-	): Promise<{ values: IssueShape[]; truncated: boolean; metadata?: CollectionMetadata } | undefined> {
+	): Promise<ProjectIssuesDrain | undefined> {
 		const tokenWithInfo = toTokenWithInfo(this.id, session);
 
 		const api = await this.getProvidersApi();
 
-		// Drain every page for a project read (bounded by a defensive backstop): the paged wrapper preserves the
-		// SDK's cursor, unlike the plain read which silently caps at the first page. `filter` undefined = the
-		// unscoped project read. Reports `truncated` when the drain stopped at the backstop with more pages
-		// still available, and records a structured failure if a page-level error discarded the rest of the drain,
-		// so the facade can warn + set fetchFailed while preserving the already-fetched prefix.
 		const projectScope = {
 			providerId: this.id,
 			resourceId: project.resourceId,
@@ -263,10 +264,10 @@ export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegratio
 			authorLogin?: string;
 			assigneeLogins?: string[];
 			mentionLogin?: string;
-		}): Promise<{ issues: ProviderIssue[]; truncated: boolean; metadata?: CollectionMetadata }> => {
+		}): Promise<JiraProjectIssuesDrain<ProviderIssue>> => {
 			const collected: ProviderIssue[] = [];
 			let cursor: string | undefined;
-			let truncated = false;
+			let status: JiraProjectIssuesDrain<ProviderIssue>['status'] = 'complete';
 			let metadata: CollectionMetadata | undefined;
 			for (let i = 0; i < maxPagesPerRequest; i++) {
 				let result: Awaited<ReturnType<typeof api.getIssuesForProjectPaged>> | undefined;
@@ -283,7 +284,7 @@ export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegratio
 					// than an empty partial success.
 					if (collected.length === 0) throw ex;
 
-					truncated = true;
+					status = 'incomplete';
 					metadata = mergeCollectionMetadata(metadata, {
 						completeness: 'partial',
 						failures: [toCollectionScopeFailure(projectScope, ex)],
@@ -293,7 +294,7 @@ export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegratio
 				if (result == null) {
 					if (cursor == null) break;
 
-					truncated = true;
+					status = 'incomplete';
 					metadata = mergeCollectionMetadata(metadata, {
 						completeness: 'partial',
 						failures: [
@@ -312,7 +313,7 @@ export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegratio
 				// The provider claims more pages but gave no advancing cursor: we can't continue, so the drain
 				// is incomplete — flag it rather than silently stopping (matches drainPullRequests/Repositories).
 				if (result.nextCursor == null || result.nextCursor === cursor) {
-					truncated = true;
+					status = 'incomplete';
 					metadata = mergeCollectionMetadata(metadata, {
 						completeness: 'partial',
 						failures: [
@@ -326,18 +327,21 @@ export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegratio
 				}
 
 				cursor = result.nextCursor;
-				// More pages remain but we're at the last allowed iteration: the drain is incomplete.
 				if (i === maxPagesPerRequest - 1) {
-					truncated = true;
+					status = 'backstop';
 				}
 			}
-			return { issues: collected, truncated: truncated, metadata: metadata };
+			return {
+				issues: collected,
+				status: status,
+				metadata: metadata,
+			};
 		};
 
 		const getSearchedUserIssuesForFilter = async (
 			user: string,
 			filter: IssueFilter,
-		): Promise<{ issues: IssueShape[]; truncated: boolean; metadata?: CollectionMetadata }> => {
+		): Promise<JiraProjectIssuesDrain<IssueShape>> => {
 			const result = await drainIssues({
 				authorLogin: filter === IssueFilter.Author ? user : undefined,
 				assigneeLogins: filter === IssueFilter.Assignee ? [user] : undefined,
@@ -348,7 +352,7 @@ export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegratio
 				issues: result.issues
 					.map(issue => toIssueShape(issue, this))
 					.filter((r): r is IssueShape => r !== undefined),
-				truncated: result.truncated,
+				status: result.status,
 				metadata: result.metadata,
 			};
 		};
@@ -415,7 +419,7 @@ export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegratio
 					continue;
 				}
 
-				if (outcome.value.truncated) {
+				if (outcome.value.status !== 'complete') {
 					truncated = true;
 				}
 				if (outcome.value.metadata != null) {
@@ -428,17 +432,23 @@ export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegratio
 				}
 			}
 
-			return { values: [...resultsById.values()], truncated: truncated, metadata: metadata };
+			return truncated
+				? { values: [...resultsById.values()], truncated: true, recovery: 'none', metadata: metadata }
+				: { values: [...resultsById.values()], truncated: false, metadata: metadata };
 		}
 
 		const unscoped = await drainIssues({});
-		return {
-			values: unscoped.issues
-				.map(issue => toIssueShape(issue, this))
-				.filter((result): result is IssueShape => result !== undefined),
-			truncated: unscoped.truncated,
-			metadata: unscoped.metadata,
-		};
+		const values = unscoped.issues
+			.map(issue => toIssueShape(issue, this))
+			.filter((result): result is IssueShape => result !== undefined);
+		return unscoped.status !== 'complete'
+			? {
+					values: values,
+					truncated: true,
+					recovery: unscoped.status === 'backstop' ? 'narrow-scope' : 'none',
+					metadata: unscoped.metadata,
+				}
+			: { values: values, truncated: false, metadata: unscoped.metadata };
 	}
 
 	protected override async searchProviderMyIssues(
@@ -516,6 +526,22 @@ export class JiraIntegration extends IssuesIntegration<IssuesCloudHostIntegratio
 		return issue != null ? { ...issue, type: 'issue' } : undefined;
 	}
 
+	protected override async getProviderIssueByResourceId(
+		session: ProviderAuthenticationSession,
+		resourceId: string,
+		id: string,
+		resourceUrl: string | undefined,
+	): Promise<Issue | undefined> {
+		if (resourceUrl == null) {
+			throw new Error('Jira direct issue reads require a resource URL');
+		}
+
+		const api = await this.getProvidersApi();
+		const apiResult = await api.getJiraIssueByKey(toTokenWithInfo(this.id, session), resourceId, resourceUrl, id);
+		const issue = apiResult != null ? toIssueShape(apiResult, this, { reliableStateCategory: true }) : undefined;
+		return issue != null ? { ...issue, type: 'issue' } : undefined;
+	}
+
 	protected override async providerOnConnect(): Promise<void> {
 		this._autolinks = undefined;
 		if (this._session == null) return;

package/src/plus/integrations/providers/jiraIssueByKey.ts

@@ -0,0 +1,155 @@
+import type { ProviderAccount, ProviderIssue, ProviderRequestFunction } from './models.js';
+
+const jiraCloudApiUrl = 'https://api.atlassian.com/ex/jira';
+const jiraIssueByKeyFields = [
+	'assignee',
+	'comment',
+	'created',
+	'creator',
+	'description',
+	'issuetype',
+	'labels',
+	'project',
+	'status',
+	'summary',
+	'updated',
+	'votes',
+];
+
+type JiraIssueMemberResponse = {
+	accountId?: string;
+	displayName?: string | null;
+	emailAddress?: string | null;
+	avatarUrls?: Record<string, string | undefined>;
+};
+
+type JiraIssueStatusResponse = {
+	id: string;
+	name: string;
+	statusCategory: {
+		colorName: string;
+		key: string;
+		name: string;
+	};
+};
+
+type JiraIssueByKeyResponse = {
+	id: string;
+	key: string;
+	fields: {
+		assignee?: JiraIssueMemberResponse | null;
+		comment?: { comments?: unknown[]; total?: number };
+		created: string;
+		creator?: JiraIssueMemberResponse | null;
+		description?: string | null;
+		issuetype?: { name?: string | null };
+		labels?: string[];
+		project?: { id?: string | null; key?: string | null; name?: string | null };
+		status: JiraIssueStatusResponse;
+		summary: string;
+		updated: string;
+		votes?: { votes?: number | null };
+	};
+};
+
+function toAccount(member: JiraIssueMemberResponse | null | undefined): ProviderAccount | null {
+	if (member == null) return null;
+
+	return {
+		id: member.accountId ?? '',
+		name: member.displayName ?? null,
+		username: member.displayName ?? null,
+		email: member.emailAddress ?? null,
+		avatarUrl: member.avatarUrls?.['48x48'] ?? null,
+		url: null,
+	};
+}
+
+function toStatusCategory(key: string): 'TO_DO' | 'IN_PROGRESS' | 'DONE' {
+	switch (key.toLowerCase()) {
+		case 'new':
+			return 'TO_DO';
+		case 'indeterminate':
+			return 'IN_PROGRESS';
+		case 'done':
+			return 'DONE';
+		default:
+			return 'TO_DO';
+	}
+}
+
+function toIssueWebUrl(resourceUrl: string, key: string): string {
+	const url = new URL(resourceUrl);
+	url.pathname = `${url.pathname.replace(/\/+$/, '')}/browse/${encodeURIComponent(key)}`;
+	url.search = '';
+	url.hash = '';
+	return url.toString();
+}
+
+function fromJiraIssueByKey(issue: JiraIssueByKeyResponse, resourceId: string, resourceUrl: string): ProviderIssue {
+	const assignee = toAccount(issue.fields.assignee);
+	const project = issue.fields.project;
+	const status = issue.fields.status;
+
+	return {
+		id: issue.id,
+		commentCount: issue.fields.comment?.total ?? issue.fields.comment?.comments?.length ?? null,
+		number: issue.key,
+		title: issue.fields.summary,
+		url: toIssueWebUrl(resourceUrl, issue.key),
+		closedDate: null,
+		createdDate: new Date(issue.fields.created),
+		author: toAccount(issue.fields.creator),
+		updatedDate: new Date(issue.fields.updated),
+		assignees: assignee != null ? [assignee] : [],
+		description: issue.fields.description ?? null,
+		repository: null,
+		project:
+			project != null
+				? {
+						name: project.name ?? '',
+						resourceId: resourceId,
+						key: project.key ?? null,
+						namespace: null,
+						id: project.id ?? null,
+					}
+				: undefined,
+		state: {
+			id: status.id,
+			name: status.name,
+			color: status.statusCategory.colorName,
+			category: toStatusCategory(status.statusCategory.key),
+		},
+		type: issue.fields.issuetype?.name ?? null,
+		upvoteCount: issue.fields.votes?.votes ?? null,
+		labels: (issue.fields.labels ?? []).map(label => ({
+			color: null,
+			description: null,
+			id: null,
+			name: label,
+		})),
+	};
+}
+
+/**
+ * The SDK's Jira point read performs resource and field discovery before the issue GET. This focused path uses
+ * caller-supplied resource identity so a cold lookup remains one upstream request.
+ */
+export async function requestJiraIssueByKey(
+	request: ProviderRequestFunction,
+	accessToken: string,
+	resourceId: string,
+	resourceUrl: string,
+	key: string,
+): Promise<ProviderIssue> {
+	const url = new URL(
+		`${jiraCloudApiUrl}/${encodeURIComponent(resourceId)}/rest/api/2/issue/${encodeURIComponent(key)}`,
+	);
+	url.searchParams.set('fields', jiraIssueByKeyFields.join(','));
+
+	const response = await request<JiraIssueByKeyResponse>({
+		url: url.toString(),
+		headers: { Authorization: `Bearer ${accessToken}` },
+	});
+	return fromJiraIssueByKey(response.body, resourceId, resourceUrl);
+}

package/src/plus/integrations/providers/linear.ts

@@ -12,7 +12,12 @@ import { toTokenWithInfo } from '../authentication/models.js';
 import { toCollectionScopeFailure } from '../collectionMetadata.js';
 import { IssuesCloudHostIntegrationId } from '../constants.js';
 import { IntegrationReadUnavailableError } from '../errors.js';
-import type { AccountWideIssuesResult, IssuesForProjectOptions, SearchMyIssuesOptions } from '../models/issueReads.js';
+import type {
+	AccountWideIssuesResult,
+	IssuesForProjectOptions,
+	ProjectIssuesDrain,
+	SearchMyIssuesOptions,
+} from '../models/issueReads.js';
 import { IssuesIntegration } from '../models/issuesIntegration.js';
 import type { ProviderApiCollectionResult, ProviderIssue } from './models.js';
 import { fromProviderIssue, providersMetadata, toIssueShape } from './models.js';
@@ -219,7 +224,7 @@ export class LinearIntegration extends IssuesIntegration<IssuesCloudHostIntegrat
 		session: ProviderAuthenticationSession,
 		project: ResourceDescriptor,
 		options?: IssuesForProjectOptions,
-	): Promise<{ values: IssueShape[]; truncated: boolean; metadata?: CollectionMetadata } | undefined> {
+	): Promise<ProjectIssuesDrain | undefined> {
 		if (!isIssueResourceDescriptor(project)) return undefined;
 
 		const api = await this.getProvidersApi();
@@ -256,6 +261,8 @@ export class LinearIntegration extends IssuesIntegration<IssuesCloudHostIntegrat
 			requestCount += 1;
 			hasMore = result.paging?.more ?? false;
 			const nextCursor = result.paging?.cursor;
+			truncated ||= result.paging?.truncated === true;
+			collectionMetadata = mergeCollectionMetadata(collectionMetadata, result.metadata);
 			for (const issue of result.values) {
 				const shape = toIssueShape(issue, this);
 				if (shape != null) {
@@ -270,7 +277,6 @@ export class LinearIntegration extends IssuesIntegration<IssuesCloudHostIntegrat
 			}
 
 			cursor = nextCursor;
-			// More pages remain but we've hit the backstop: the drain is incomplete.
 			if (hasMore && requestCount >= maxPagesPerRequest) {
 				truncated = true;
 			}
@@ -294,14 +300,16 @@ export class LinearIntegration extends IssuesIntegration<IssuesCloudHostIntegrat
 					'could not resolve the current user to scope issues to',
 				);
 			}
-			return {
-				values: issues.filter(issue => issue.assignees?.some(a => a.id === viewerId)),
-				truncated: truncated,
-				metadata: collectionMetadata,
-			};
+
+			const values = issues.filter(issue => issue.assignees?.some(a => a.id === viewerId));
+			return truncated
+				? { values: values, truncated: true, recovery: 'none', metadata: collectionMetadata }
+				: { values: values, truncated: false, metadata: collectionMetadata };
 		}
 
-		return { values: issues, truncated: truncated, metadata: collectionMetadata };
+		return truncated
+			? { values: issues, truncated: true, recovery: 'none', metadata: collectionMetadata }
+			: { values: issues, truncated: false, metadata: collectionMetadata };
 	}
 
 	override get id(): IssuesCloudHostIntegrationId.Linear {
@@ -433,30 +441,35 @@ export class LinearIntegration extends IssuesIntegration<IssuesCloudHostIntegrat
 		return result && fromProviderIssue(result, this);
 	}
 
+	protected override async getProviderIssueByResourceId(
+		session: ProviderAuthenticationSession,
+		resourceId: string,
+		id: string,
+		_resourceUrl: string | undefined,
+	): Promise<Issue | undefined> {
+		const api = await this.getProvidersApi();
+		const result = await api.getIssue(toTokenWithInfo(this.id, session), {
+			resourceId: resourceId,
+			number: id,
+		});
+		return result && fromProviderIssue(result, this);
+	}
+
 	private async getRawProviderIssue(
 		session: ProviderAuthenticationSession,
 		resource: ResourceDescriptor,
 		id: string,
 	): Promise<ProviderIssue | undefined> {
 		const api = await this.getProvidersApi();
-		try {
-			if (!isIssueResourceDescriptor(resource)) {
-				Logger.error(undefined, 'getProviderIssue: resource is not an IssueResourceDescriptor');
-				return undefined;
-			}
-
-			const result = await api.getIssue(toTokenWithInfo(this.id, session), {
-				resourceId: resource.id,
-				number: id,
-			});
-
-			if (result == null) return undefined;
-
-			return result;
-		} catch (ex) {
-			Logger.error(ex, 'getProviderIssue');
+		if (!isIssueResourceDescriptor(resource)) {
+			Logger.error(undefined, 'getProviderIssue: resource is not an IssueResourceDescriptor');
 			return undefined;
 		}
+
+		return api.getIssue(toTokenWithInfo(this.id, session), {
+			resourceId: resource.id,
+			number: id,
+		});
 	}
 	private getIssueAutolinkLikeUrl(issue: ProviderIssue): string | null {
 		const url = issue.url;

package/src/plus/integrations/providers/models.ts

@@ -1229,13 +1229,24 @@ function toIssueIdentifier(value: string | number): string {
 	return String(value);
 }
 
-export function toIssueShape(issue: ProviderIssue, provider: ProviderReference): IssueShape | undefined {
+export function toIssueShape(
+	issue: ProviderIssue,
+	provider: ProviderReference,
+	options?: { reliableStateCategory?: boolean },
+): IssueShape | undefined {
 	// TODO: Add some protections/baselines rather than killing the transformation here
 	// `author` is intentionally not required: some providers have no per-item creator (e.g. Trello cards,
 	// which the SDK maps with `author: null`), and dropping every such item would discard the whole board.
 	// Fall back to an empty author instead so these issues still surface.
 	if (issue.updatedDate == null || issue.url == null) return undefined;
 
+	// Jira SDK results derive this category from a localized display name and default unknown names to DONE.
+	// Only the direct point read opts in because it maps Jira's stable status-category key itself.
+	const closed =
+		issue.closedDate != null ||
+		(issue.state?.category === 'DONE' &&
+			(provider.id !== IssuesCloudHostIntegrationId.Jira || options?.reliableStateCategory === true));
+
 	return {
 		type: 'issue',
 		provider: provider,
@@ -1254,8 +1265,8 @@ export function toIssueShape(issue: ProviderIssue, provider: ProviderReference):
 		createdDate: issue.createdDate,
 		updatedDate: issue.updatedDate,
 		closedDate: issue.closedDate ?? undefined,
-		closed: issue.closedDate != null,
-		state: issue.closedDate != null ? 'closed' : 'opened',
+		closed: closed,
+		state: closed ? 'closed' : 'opened',
 		author: {
 			id: issue.author?.id ?? '',
 			// An absent name stays absent, matching {@link fromProviderAccount}; see `IssueMember.name`.
@@ -1688,6 +1699,7 @@ export function fromProviderIssue(
 	options?: { project?: IssueProject },
 ): Issue {
 	const identifier = toIssueIdentifier(issue.number);
+	const closed = issue.closedDate != null || issue.state?.category === 'DONE';
 	return new Issue(
 		integration,
 		identifier,
@@ -1696,8 +1708,8 @@ export function fromProviderIssue(
 		issue.url ?? '',
 		issue.createdDate,
 		issue.updatedDate ?? issue.closedDate ?? issue.createdDate,
-		issue.closedDate != null,
-		issue.closedDate != null ? 'closed' : 'opened',
+		closed,
+		closed ? 'closed' : 'opened',
 		fromProviderAccount(issue.author),
 		issue.assignees?.map(fromProviderAccount) ?? undefined,
 		issue.repository != null

package/src/plus/integrations/providers/providerErrors.ts

@@ -0,0 +1,115 @@
+import type { TokenWithInfo } from '../authentication/models.js';
+import type { IntegrationIds } from '../constants.js';
+import { IssuesCloudHostIntegrationId } from '../constants.js';
+import {
+	AuthenticationError,
+	AuthenticationErrorReason,
+	isRateLimitResponse,
+	RequestClientError,
+	RequestNotFoundError,
+	toError,
+	toRateLimitError,
+} from '../errors.js';
+
+const linearIssueNotFoundMessage = /^Linear issue not found: .+$/i;
+const maxProviderErrorBodyLength = 500;
+
+type ProviderGraphQLError = {
+	message?: unknown;
+	extensions?: { code?: unknown };
+};
+
+function getProviderGraphQLErrors(body: unknown): ProviderGraphQLError[] {
+	if (body == null || typeof body !== 'object') return [];
+
+	const errors = (body as { errors?: unknown }).errors;
+	return Array.isArray(errors)
+		? errors.filter((error): error is ProviderGraphQLError => error != null && typeof error === 'object')
+		: [];
+}
+
+function isLinearRateLimitError(providerId: IntegrationIds, ex: unknown): boolean {
+	if (providerId !== IssuesCloudHostIntegrationId.Linear) return false;
+
+	const body = (ex as { response?: { body?: unknown } }).response?.body;
+	return getProviderGraphQLErrors(body).some(error => error.extensions?.code === 'RATELIMITED');
+}
+
+export function isProviderIssueNotFoundError(providerId: IntegrationIds, ex: unknown): boolean {
+	if (providerId === IssuesCloudHostIntegrationId.Linear) {
+		return ex instanceof Error && linearIssueNotFoundMessage.test(ex.message);
+	}
+
+	const status = (ex as { response?: { status?: unknown } }).response?.status;
+	return status === 404 || status === 410 || status === 422;
+}
+
+export function throwProviderError(tokenWithInfo: TokenWithInfo, error: unknown): never {
+	const { accessToken: token, ...tokenInfo } = tokenWithInfo;
+	const providerId = tokenWithInfo.providerId;
+	const normalizedError = toError(error);
+	// Linear reports GraphQL throttling as HTTP 400, so its structured code must win over generic 4xx handling.
+	if (isLinearRateLimitError(providerId, error)) {
+		throw toRateLimitError(normalizedError, token);
+	}
+
+	const status = (error as { response?: { status?: unknown } }).response?.status;
+	if (typeof status === 'number') {
+		switch (status) {
+			case 404:
+			case 410:
+			case 422:
+				throw new RequestNotFoundError(normalizedError);
+			case 429:
+				throw toRateLimitError(normalizedError, token);
+			case 401:
+			case 403:
+				// Some hosts overload 403 for throttling; classify that before asking the user to reconnect.
+				if (isRateLimitResponse({ status: status, message: normalizedError.message })) {
+					throw toRateLimitError(normalizedError, token);
+				}
+				throw new AuthenticationError(
+					tokenInfo,
+					status === 401 ? AuthenticationErrorReason.Unauthorized : AuthenticationErrorReason.Forbidden,
+					normalizedError,
+				);
+			default:
+				if (status >= 400 && status < 500) {
+					throw new RequestClientError(normalizedError);
+				}
+		}
+	}
+
+	throw error;
+}
+
+/** Extracts the useful provider prose from an already-parsed SDK response body. */
+export function getProviderResponseBodyMessage(body: unknown): string | undefined {
+	let message: string | undefined;
+	if (typeof body === 'string') {
+		message = body;
+	} else if (body != null && typeof body === 'object') {
+		const { message: direct, error } = body as { message?: unknown; error?: unknown };
+		if (typeof direct === 'string') {
+			message = direct;
+		} else if (typeof error === 'string') {
+			message = error;
+		} else if (error != null && typeof error === 'object') {
+			const nested = (error as { message?: unknown }).message;
+			if (typeof nested === 'string') {
+				message = nested;
+			}
+		}
+		if (message == null) {
+			const graphQLError = getProviderGraphQLErrors(body)[0];
+			if (typeof graphQLError?.message === 'string') {
+				message = graphQLError.message;
+			} else if (typeof graphQLError?.extensions?.code === 'string') {
+				message = graphQLError.extensions.code;
+			}
+		}
+	}
+
+	message = message?.trim();
+	return message ? message.slice(0, maxProviderErrorBodyLength) : undefined;
+}