@oomol-lab/open-connector 1.6.5 → 1.7.0

package/src/providers/keepa/deal-attributes.d.ts

@@ -0,0 +1 @@
+export declare const keepaDealAttributeNames: readonly ["material", "type", "manufacturer", "brand", "model", "color", "size", "unitType", "scent", "itemForm", "pattern", "style", "itemTypeKeyword", "targetAudienceKeyword", "edition", "format", "author", "binding", "languages", "brandStoreName", "brandStoreUrlName", "websiteDisplayGroup", "websiteDisplayGroupName", "salesRankDisplayGroup"];

package/src/providers/keepa/deal-attributes.js

@@ -0,0 +1,26 @@
+export const keepaDealAttributeNames = [
+    "material",
+    "type",
+    "manufacturer",
+    "brand",
+    "model",
+    "color",
+    "size",
+    "unitType",
+    "scent",
+    "itemForm",
+    "pattern",
+    "style",
+    "itemTypeKeyword",
+    "targetAudienceKeyword",
+    "edition",
+    "format",
+    "author",
+    "binding",
+    "languages",
+    "brandStoreName",
+    "brandStoreUrlName",
+    "websiteDisplayGroup",
+    "websiteDisplayGroupName",
+    "salesRankDisplayGroup",
+];

package/src/providers/keepa/runtime.js

@@ -1,6 +1,7 @@
 import { compactObject, optionalRawString, optionalRecord, rawStringOrNull } from "../../core/cast.js";
-import { createProviderTimeout, isAbortLikeError, ProviderRequestError, providerUserAgent, readProviderTextBody, requiredInputString, } from "../provider-runtime.js";
+import { createProviderTimeout, isAbortLikeError, providerInputError, ProviderRequestError, providerUserAgent, readProviderTextBody, requiredInputString, } from "../provider-runtime.js";
 import { keepaDealPriceTypes as dealPriceTypes, keepaHistoryTypes as historyTypes } from "./actions.js";
+import { keepaDealAttributeNames } from "./deal-attributes.js";
 export const keepaApiBaseUrl = "https://api.keepa.com";
 const keepaTimeStartMinutes = 21_564_000;
 const keepaDefaultTimeoutMs = 120_000;
@@ -211,6 +212,137 @@ export const keepaActionHandlers = {
             meta: normalizeMeta(payload),
         };
     },
+    async search_products(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const payload = await requestKeepaAction(context, {
+            path: "/search",
+            query: {
+                domain: marketplaceDomainIdByCode[marketplace],
+                type: "product",
+                term: requiredInputString(input.term, "term"),
+                ...(input.asinsOnly === true ? { "asins-only": 1 } : {}),
+                ...buildStatsQuery(input),
+                ...(typeof input.updateHours === "number" ? { update: input.updateHours } : {}),
+                ...(input.includeHistory === false ? { history: 0 } : {}),
+                ...(input.includeRating === true ? { rating: 1 } : {}),
+            },
+        });
+        const products = readObjectArray(payload.products).map(normalizeProductSnapshot);
+        return {
+            marketplace,
+            asins: input.asinsOnly === true ? readStringArray(payload.asinList) : products.map((product) => product.asin),
+            products,
+            meta: normalizeMeta(payload),
+        };
+    },
+    async lookup_categories(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const categoryIds = readIntegerArray(input.categoryIds);
+        if (categoryIds.includes(0) && categoryIds.length !== 1) {
+            throw providerInputError("root category lookup must use categoryIds [0] alone");
+        }
+        const payload = await requestKeepaAction(context, {
+            path: "/category",
+            query: {
+                domain: marketplaceDomainIdByCode[marketplace],
+                category: categoryIds.join(","),
+                parents: input.includeParents === true ? 1 : 0,
+            },
+        });
+        return {
+            marketplace,
+            categories: objectMapValues(payload.categories),
+            categoryParents: objectMapValues(payload.categoryParents),
+            meta: normalizeMeta(payload),
+        };
+    },
+    async find_sellers(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const filters = optionalRecord(input.filters);
+        if (!filters)
+            throw providerInputError("filters must be an object");
+        if (!Object.keys(filters).some((key) => !["page", "perPage", "sort", "minMatch"].includes(key))) {
+            throw providerInputError("Seller Finder requires at least one business filter");
+        }
+        const page = typeof filters.page === "number" ? filters.page : 0;
+        const perPage = filters.perPage === 0 ? 100 : typeof filters.perPage === "number" ? filters.perPage : 50;
+        if (page > 0 && page * perPage >= 10_000) {
+            throw providerInputError("Seller Finder page starts beyond the 10000-result limit");
+        }
+        const payload = await requestKeepaAction(context, {
+            path: "/sellerquery",
+            query: { domain: marketplaceDomainIdByCode[marketplace] },
+            body: filters,
+        });
+        return {
+            marketplace,
+            sellerIds: readStringArray(payload.sellerIdList),
+            totalResults: asNullableInteger(payload.totalResults),
+            meta: normalizeMeta(payload),
+        };
+    },
+    async get_most_rated_sellers(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const payload = await requestKeepaAction(context, {
+            path: "/topseller",
+            query: { domain: marketplaceDomainIdByCode[marketplace] },
+        });
+        const window = windowList(readStringArray(payload.sellerIdList), input);
+        return { marketplace, sellerIds: window.items, ...window.info, meta: normalizeMeta(payload) };
+    },
+    async get_seller_storefront(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const sellerId = requiredInputString(input.sellerId, "sellerId");
+        const payload = await requestKeepaAction(context, {
+            path: "/seller",
+            query: { domain: marketplaceDomainIdByCode[marketplace], seller: sellerId, storefront: 1 },
+        });
+        const seller = optionalRecord(optionalRecord(payload.sellers)?.[sellerId]);
+        const asins = readStringArray(seller?.asinList);
+        const lastSeen = Array.isArray(seller?.asinListLastSeen) ? seller.asinListLastSeen : [];
+        const window = windowList(asins.map((asin, index) => ({ asin, lastSeen: asNullableInteger(lastSeen[index]) })), input);
+        const { asinList: _asinList, asinListLastSeen: _asinListLastSeen, ...sellerWithoutList } = seller ?? {};
+        return {
+            marketplace,
+            seller: seller ? normalizeSeller(sellerId, sellerWithoutList) : null,
+            items: window.items,
+            ...window.info,
+            meta: normalizeMeta(payload),
+        };
+    },
+    async get_lightning_deal(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const payload = await requestKeepaAction(context, {
+            path: "/lightningdeal",
+            query: {
+                domain: marketplaceDomainIdByCode[marketplace],
+                asin: requiredInputString(input.asin, "asin"),
+                ...(typeof input.state === "string" ? { state: input.state } : {}),
+            },
+        });
+        return {
+            marketplace,
+            lightningDeals: readObjectArray(payload.lightningDeals),
+            meta: normalizeMeta(payload),
+        };
+    },
+    async list_lightning_deals(input, context) {
+        const marketplace = requireMarketplace(input.marketplace);
+        const payload = await requestKeepaAction(context, {
+            path: "/lightningdeal",
+            query: {
+                domain: marketplaceDomainIdByCode[marketplace],
+                ...(typeof input.state === "string" ? { state: input.state } : {}),
+            },
+        });
+        const window = windowList(readObjectArray(payload.lightningDeals), input);
+        return {
+            marketplace,
+            lightningDeals: window.items,
+            ...window.info,
+            meta: normalizeMeta(payload),
+        };
+    },
 };
 export async function validateKeepaCredential(apiKey, fetcher, signal) {
     const payload = await requestKeepa({
@@ -232,39 +364,80 @@ export async function validateKeepaCredential(apiKey, fetcher, signal) {
         },
     };
 }
+function requestKeepaAction(context, input) {
+    return requestKeepa({ ...input, context, phase: "execute" });
+}
 function buildProductQuery(input, marketplace, history) {
-    const asins = readAsinArray(input.asins);
-    assertProductRequestRules(input, asins);
+    const asins = input.asins === undefined ? [] : readAsinArray(input.asins);
+    const codes = readStringArray(input.codes).map((code) => code.trim());
+    if ((asins.length === 0) === (codes.length === 0)) {
+        throw providerInputError("provide either asins or codes");
+    }
+    const itemCount = asins.length || codes.length;
+    if (typeof input.offers === "number" && itemCount > 20) {
+        throw providerInputError("offers can only be requested for up to 20 ASINs or product codes");
+    }
+    if (input.codeLimit !== undefined && codes.length === 0) {
+        throw providerInputError("codeLimit requires codes");
+    }
+    if (input.onlyLiveOffers === true && typeof input.offers !== "number") {
+        throw providerInputError("onlyLiveOffers requires offers");
+    }
+    if (input.includeStock === true && typeof input.offers !== "number") {
+        throw providerInputError("includeStock requires offers");
+    }
     return {
-        asin: asins.join(","),
+        ...(asins.length > 0 ? { asin: asins.join(",") } : { code: codes.join(",") }),
         domain: marketplaceDomainIdByCode[marketplace],
         history: history ? 1 : 0,
-        ...(typeof input.statsDays === "number" ? { stats: input.statsDays } : {}),
+        ...buildStatsQuery(input),
+        ...(typeof input.codeLimit === "number" ? { "code-limit": input.codeLimit } : {}),
         ...(typeof input.updateHours === "number" ? { update: input.updateHours } : {}),
         ...(typeof input.offers === "number" ? { offers: input.offers } : {}),
         ...(input.onlyLiveOffers === true ? { "only-live-offers": 1 } : {}),
         ...(input.includeBuyBox === true ? { buybox: 1 } : {}),
         ...(input.includeRating === true ? { rating: 1 } : {}),
+        ...(input.includeVideos === true ? { videos: 1 } : {}),
+        ...(input.includeAPlus === true ? { aplus: 1 } : {}),
+        ...(input.includeStock === true ? { stock: 1 } : {}),
+        ...(input.includeHistoricalVariations === true ? { "historical-variations": 1 } : {}),
     };
 }
+function buildStatsQuery(input) {
+    const range = optionalRecord(input.statsRange);
+    if (input.statsDays !== undefined && range) {
+        throw providerInputError("statsDays and statsRange are mutually exclusive");
+    }
+    if (range) {
+        const start = typeof range.start === "number" ? range.start : Date.parse(String(range.start));
+        const end = typeof range.end === "number" ? range.end : Date.parse(String(range.end));
+        if (typeof range.start !== typeof range.end || start >= end) {
+            throw providerInputError("statsRange requires matching types and start before end");
+        }
+        return { stats: `${range.start},${range.end}` };
+    }
+    return typeof input.statsDays === "number" ? { stats: input.statsDays } : {};
+}
 function buildDealRequest(input, marketplace, priceType) {
     const metricDefinition = keepaMetricByType.get(priceType);
     if (!metricDefinition) {
-        throw new ProviderRequestError(400, `unsupported deal price type: ${priceType}`);
+        throw providerInputError(`unsupported deal price type: ${priceType}`);
     }
     const sortName = typeof input.sortBy === "string" && input.sortBy in dealSortTypeByName
         ? input.sortBy
         : "newest";
     const sortType = dealSortTypeByName[sortName];
     if (sortType === 1 && input.invertSort === true) {
-        throw new ProviderRequestError(400, "newest deal sorting cannot be inverted");
+        throw providerInputError("newest deal sorting cannot be inverted");
     }
     const ranges = {
         currentRange: readOptionalIntegerArray(input.currentRange),
         deltaRange: readOptionalIntegerArray(input.deltaRange),
         deltaPercentRange: readOptionalIntegerArray(input.deltaPercentRange),
+        deltaLastRange: readOptionalIntegerArray(input.deltaLastRange),
         salesRankRange: readOptionalIntegerArray(input.salesRankRange),
     };
+    const attributes = Object.fromEntries(keepaDealAttributeNames.map((name) => [name, readOptionalStringArray(input[name])]));
     return compactObject({
         page: typeof input.page === "number" ? input.page : 0,
         domainId: marketplaceDomainIdByCode[marketplace],
@@ -274,13 +447,17 @@ function buildDealRequest(input, marketplace, priceType) {
         isLowest: input.isLowestEver === true,
         isLowest90: input.isLowest90Days === true,
         isLowestOffer: input.isLowestOffer === true,
+        isHighest: input.isHighest === true,
         isBackInStock: input.isBackInStock === true,
         isOutOfStock: input.isOutOfStock === true,
         hasReviews: input.hasReviews === true,
         isPrimeExclusive: input.isPrimeExclusive === true,
         mustHaveAmazonOffer: input.mustHaveAmazonOffer === true,
         mustNotHaveAmazonOffer: input.mustNotHaveAmazonOffer === true,
-        filterErotic: true,
+        filterErotic: typeof input.filterErotic === "boolean" ? input.filterErotic : undefined,
+        singleVariation: input.singleVariation === true,
+        isRisers: input.isRisers === true,
+        warehouseConditions: readOptionalIntegerArray(input.warehouseConditions),
         isRangeEnabled: Object.values(ranges).some((value) => value !== undefined),
         isFilterEnabled: [
             input.isLowestEver,
@@ -292,16 +469,38 @@ function buildDealRequest(input, marketplace, priceType) {
             input.isPrimeExclusive,
             input.mustHaveAmazonOffer,
             input.mustNotHaveAmazonOffer,
+            input.isHighest,
+            input.singleVariation,
+            input.isRisers,
+            input.warehouseConditions,
             input.minimumRating,
             input.titleSearch,
-        ].some((value) => value !== undefined && value !== false),
+            ...Object.values(attributes),
+        ].some((value) => value !== undefined && value !== false) || input.filterErotic !== undefined,
         includeCategories: readOptionalIntegerArray(input.includeCategories),
         excludeCategories: readOptionalIntegerArray(input.excludeCategories),
-        titleSearch: optionalRawString(input.titleSearch),
+        titleSearch: typeof input.titleSearch === "string" ? input.titleSearch : undefined,
         minRating: typeof input.minimumRating === "number" ? input.minimumRating : undefined,
         ...ranges,
+        ...attributes,
     });
 }
+function windowList(items, input) {
+    const offset = typeof input.offset === "number" ? input.offset : 0;
+    const limit = input.limit === null ? null : typeof input.limit === "number" ? input.limit : 100;
+    const result = items.slice(offset, limit === null ? undefined : offset + limit);
+    const next = offset + result.length;
+    const hasMore = next < items.length;
+    return {
+        items: result,
+        info: {
+            totalAvailable: items.length,
+            returnedCount: result.length,
+            hasMore,
+            nextOffset: hasMore ? next : null,
+        },
+    };
+}
 async function requestKeepa(input) {
     const url = new URL(input.path, keepaApiBaseUrl);
     url.searchParams.set("key", input.context.apiKey);
@@ -617,14 +816,6 @@ function validateCategorySearchTerm(term) {
         throw new ProviderRequestError(400, "each category search keyword must contain at least three characters");
     }
 }
-function assertProductRequestRules(input, asins) {
-    if (typeof input.offers === "number" && asins.length > 20) {
-        throw new ProviderRequestError(400, "offers can only be requested for up to 20 ASINs");
-    }
-    if (input.onlyLiveOffers === true && typeof input.offers !== "number") {
-        throw new ProviderRequestError(400, "onlyLiveOffers requires offers");
-    }
-}
 function requireInputObject(value, fieldName) {
     const object = optionalRecord(value);
     if (!object) {
@@ -683,6 +874,9 @@ function readIntegerArray(value) {
 function readOptionalIntegerArray(value) {
     return Array.isArray(value) ? readIntegerArray(value) : undefined;
 }
+function readOptionalStringArray(value) {
+    return Array.isArray(value) ? readStringArray(value) : undefined;
+}
 function objectMapValues(value) {
     const object = optionalRecord(value);
     if (!object) {

package/src/providers/kingdee/executors.js

@@ -26,7 +26,7 @@ export const proxy = defineProviderProxy({
     allowedEndpoint: isBusinessEndpoint,
     allowPrivateNetwork: isPrivateNetworkAccessAllowed,
     sensitiveHeaders: ["kdservice-sessionid"],
-    redirect: "error",
+    redirect: "manual",
     async customizeRequest({ context, fetcher, headers }) {
         const values = (await requireCustomCredential(context, service)).values;
         const kingdee = readCredential(values);

package/src/providers/kingdee/runtime.js

@@ -57,7 +57,7 @@ export async function login(credential, fetcher, parentSignal) {
     return runProviderRequest({ label: "Kingdee login", signal: parentSignal }, async (signal) => {
         const response = await fetcher(new URL("Kingdee.BOS.WebApi.ServicesStub.AuthService.LoginByAppSecret.common.kdsvc", credential.baseUrl), {
             method: "POST",
-            redirect: "error",
+            redirect: "manual",
             signal,
             headers: { "content-type": "application/json", accept: "application/json" },
             body: JSON.stringify({
@@ -111,7 +111,7 @@ async function execute(action, input, context) {
         const response = await context.fetcher(new URL(`Kingdee.BOS.WebApi.ServicesStub.DynamicFormService.${kingdeeMethods[action]}.common.kdsvc`, context.credential.baseUrl), {
             method: "POST",
             signal,
-            redirect: "error",
+            redirect: "manual",
             headers: { "content-type": "application/json", "kdservice-sessionid": sessionId },
             body: JSON.stringify(body),
         });

package/src/providers/kuaidi100/runtime.js

@@ -150,7 +150,7 @@ function withKuaidi100Client(context, phase, run) {
         transport: "streamable_http",
         fetcher: context.fetcher,
         headers: { responseFormat: "json", "user-agent": providerUserAgent },
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError: (error) => mapKuaidi100McpError(error, phase),
     }, run);

package/src/providers/linear/executors.js

@@ -1,5 +1,5 @@
 import { compactObject, optionalBoolean } from "../../core/cast.js";
-import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, toProviderProxyError, } from "../provider-runtime.js";
+import { createProviderFetch, createProviderProxyUrl, defineProviderExecutors, normalizeProviderProxyHeaders, ProviderRequestError, providerUserAgent, readProviderProxyErrorMessage, readProviderProxyResponse, toProviderProxyError, withRetryAfterSeconds, } from "../provider-runtime.js";
 const linearApiBaseUrl = "https://api.linear.app";
 const linearGraphqlUrl = "https://api.linear.app/graphql";
 const linearFetch = createProviderFetch({ skipDnsValidation: true });
@@ -697,8 +697,8 @@ export const linearActionHandlers = {
     async list_linear_issues(input, context) {
         const assigneeId = await resolveAssigneeFilterId(context, getOptionalString(input.assignee_id));
         const payload = await linearGraphqlOperation(context, `
-        query ListLinearIssues($after: String, $first: Int, $filter: IssueFilter) {
-          issues(after: $after, first: $first, includeArchived: false, filter: $filter) {
+        query ListLinearIssues($after: String, $first: Int, $filter: IssueFilter, $includeArchived: Boolean, $orderBy: PaginationOrderBy) {
+          issues(after: $after, first: $first, includeArchived: $includeArchived, filter: $filter, orderBy: $orderBy) {
             nodes {
               ${issueFields}
             }
@@ -710,7 +710,9 @@ export const linearActionHandlers = {
       `, {
             after: getOptionalString(input.after),
             first: getOptionalNumber(input.first),
-            filter: buildIssuesFilter(getOptionalString(input.project_id), assigneeId),
+            filter: buildIssuesFilter(getOptionalString(input.project_id), assigneeId, getOptionalString(input.updated_after)),
+            includeArchived: optionalBoolean(input.include_archived) ?? false,
+            orderBy: getOptionalString(input.order_by),
         });
         return {
             issues: (payload.issues?.nodes ?? []).map(mapIssueSummary),
@@ -1051,7 +1053,7 @@ export const proxy = async (input, context) => {
         const response = await linearFetch(url, init);
         if (!response.ok) {
             const text = await readProviderProxyErrorMessage(response, "");
-            throw new ProviderRequestError(response.status, text || `linear request failed with HTTP ${response.status}`);
+            throw new ProviderRequestError(response.status, text || `linear request failed with HTTP ${response.status}`, withRetryAfterSeconds(response));
         }
         return { ok: true, response: await readProviderProxyResponse(response) };
     }
@@ -1117,7 +1119,7 @@ async function linearGraphqlRequest(authorization, fetcher, query, variables) {
     });
     const body = await readJson(response);
     if (!response.ok) {
-        throwLinearHttpError(response.status, body);
+        throwLinearHttpError(response.status, body, withRetryAfterSeconds(response));
     }
     return body;
 }
@@ -1454,10 +1456,11 @@ async function resolveAssigneeFilterId(context, assigneeId) {
     const viewer = await fetchLinearViewer(context.authorization, context.fetcher);
     return String(viewer.id);
 }
-function buildIssuesFilter(projectId, assigneeId) {
+function buildIssuesFilter(projectId, assigneeId, updatedAfter) {
     const filter = compactObject({
         project: projectId ? { id: { eq: projectId } } : undefined,
         assignee: assigneeId ? { id: { eq: assigneeId } } : undefined,
+        updatedAt: updatedAfter ? { gte: updatedAfter } : undefined,
     });
     return Object.keys(filter).length > 0 ? filter : undefined;
 }
@@ -1800,7 +1803,7 @@ async function readJson(response) {
         };
     }
 }
-function throwLinearHttpError(status, body) {
+function throwLinearHttpError(status, body, details) {
     const message = extractErrorMessage(body);
     if (status === 400) {
         throw new ProviderRequestError(400, message);
@@ -1809,7 +1812,7 @@ function throwLinearHttpError(status, body) {
         throw new ProviderRequestError(401, message);
     }
     if (status === 429) {
-        throw new ProviderRequestError(429, message);
+        throw new ProviderRequestError(429, message, details);
     }
     throw new ProviderRequestError(502, message, status >= 500 ? 500 : status);
 }

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

@@ -0,0 +1,47 @@
+import type { ActionDefinition } from "../../core/types.ts";
+/** The signed-in Linear user as the MCP get_user tool reports it. */
+export interface LinearMcpUser {
+    id: string;
+    email?: string;
+    displayName?: string;
+    name?: string;
+}
+/**
+ * Typed fields lifted from one Linear MCP issue record. Linear publishes no
+ * output schema for its MCP tools, so every field but `id` is best effort and
+ * the untouched text travels beside it as `raw`.
+ */
+export interface LinearMcpIssue {
+    id: string;
+    identifier?: string;
+    uuid?: string;
+    title?: string;
+    description?: string;
+    descriptionTruncated?: boolean;
+    url?: string;
+    state?: string;
+    priority?: unknown;
+    assignee?: string;
+    assigneeId?: string;
+    creator?: string;
+    creatorId?: string;
+    team?: string;
+    project?: string;
+    labels?: string[];
+    createdAt?: string;
+    updatedAt?: string;
+    archivedAt?: string;
+    completedAt?: string;
+    dueDate?: string;
+}
+/** Typed fields lifted from one Linear MCP comment record. */
+export interface LinearMcpComment {
+    id: string;
+    body?: string;
+    user?: string;
+    userId?: string;
+    createdAt?: string;
+    updatedAt?: string;
+    url?: string;
+}
+export declare const linearMcpActions: ActionDefinition[];

package/src/providers/linear_mcp/actions.js

@@ -0,0 +1,102 @@
+import { s } from "../../core/json-schema.js";
+import { defineProviderAction } from "../../core/provider-definition.js";
+const service = "linear_mcp";
+const readScope = ["read"];
+const rawSchema = s.string("The untouched text Linear's MCP tool returned. Read it when a typed field is missing: Linear can change its MCP output shape without notice.");
+const userSchema = s.looseObject("The signed-in Linear user.", {
+    id: s.nonEmptyString("Linear user ID; the same viewer ID the Linear GraphQL API reports."),
+    email: s.optional(s.string("The user's email address, when returned.")),
+    displayName: s.optional(s.string("The user's display name, when returned.")),
+    name: s.optional(s.string("The user's full name, when returned.")),
+});
+const issueSchema = s.looseObject("A Linear issue. Typed fields are lifted from the MCP record when present; fields not listed here are only in the action's raw text.", {
+    id: s.nonEmptyString("Issue ID as Linear MCP returned it. This may be the human identifier such as ENG-123 rather than the UUID; see identifier and uuid."),
+    identifier: s.optional(s.string("Human identifier such as ENG-123, when known.")),
+    uuid: s.optional(s.string("Issue UUID, when known.")),
+    title: s.optional(s.string("Issue title.")),
+    description: s.optional(s.string("Issue description in Markdown. Linear MCP may clip it in lists; see descriptionTruncated.")),
+    descriptionTruncated: s.optional(s.boolean("Whether the description carries Linear's truncation marker. Call get_issue for the full text.")),
+    url: s.optional(s.string("Link to the issue in Linear.")),
+    state: s.optional(s.string("Workflow state name.")),
+    priority: s.optional(s.unknown("Priority as returned: a number or a label.")),
+    assignee: s.optional(s.string("Assignee name, when assigned.")),
+    assigneeId: s.optional(s.string("Assignee user ID, when the record carries one.")),
+    creator: s.optional(s.string("Creator name, when returned.")),
+    creatorId: s.optional(s.string("Creator user ID, when the record carries one.")),
+    team: s.optional(s.string("Team name or key.")),
+    project: s.optional(s.string("Project name, when the issue belongs to one.")),
+    labels: s.optional(s.stringArray("Label names.")),
+    createdAt: s.optional(s.string("Creation time as returned by Linear.")),
+    updatedAt: s.optional(s.string("Last update time as returned by Linear.")),
+    archivedAt: s.optional(s.string("Archive time, when archived.")),
+    completedAt: s.optional(s.string("Completion time, when completed.")),
+    dueDate: s.optional(s.string("Due date, when set.")),
+});
+const commentSchema = s.looseObject("A Linear issue comment.", {
+    id: s.nonEmptyString("Comment ID."),
+    body: s.optional(s.string("Comment body in Markdown.")),
+    user: s.optional(s.string("Author name, when returned.")),
+    userId: s.optional(s.string("Author user ID, when the record carries one.")),
+    createdAt: s.optional(s.string("Creation time as returned by Linear.")),
+    updatedAt: s.optional(s.string("Last edit time, when returned.")),
+    url: s.optional(s.string("Link to the comment in Linear.")),
+});
+const listIssuesInputSchema = s.object("Filters forwarded to Linear's MCP list_issues tool. Which filters the tool honours is decided by Linear's server; unknown values are rejected there.", {
+    updatedAt: s.string("Only issues updated at or after this time, as the tool accepts it (an ISO 8601 timestamp or a relative duration such as -P1D)."),
+    orderBy: s.string("Sort field, such as updatedAt or createdAt."),
+    limit: s.integer("Maximum number of issues to return on this page.", { minimum: 1, maximum: 250 }),
+    cursor: s.nonEmptyString("Cursor returned by the previous page of the same query."),
+}, { optional: ["updatedAt", "orderBy", "limit", "cursor"] });
+export const linearMcpActions = [
+    defineProviderAction(service, {
+        name: "get_self",
+        operationType: "read",
+        description: "Get the signed-in Linear user through Linear's MCP get_user tool.",
+        requiredScopes: readScope,
+        inputSchema: s.object({}),
+        outputSchema: s.requiredObject("The signed-in user.", {
+            user: s.nullable(userSchema),
+            raw: rawSchema,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "list_issues",
+        operationType: "read",
+        description: "List Linear issues through Linear's MCP list_issues tool with optional updated-since, ordering, limit, and cursor pagination. Descriptions may be clipped; call get_issue for the full text.",
+        requiredScopes: readScope,
+        followUpActions: ["linear_mcp.get_issue", "linear_mcp.list_comments"],
+        inputSchema: listIssuesInputSchema,
+        outputSchema: s.requiredObject("One page of issues.", {
+            issues: s.array("Issues on this page.", issueSchema),
+            hasNextPage: s.boolean("Whether another page follows."),
+            cursor: s.nullable(s.string("Cursor for the next page, when one is available.")),
+            raw: rawSchema,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "get_issue",
+        operationType: "read",
+        description: "Get one Linear issue with its full description through Linear's MCP get_issue tool.",
+        requiredScopes: readScope,
+        inputSchema: s.requiredObject("The issue to read.", {
+            id: s.nonEmptyString("Issue ID or human identifier such as ENG-123, as returned by list_issues."),
+        }),
+        outputSchema: s.requiredObject("The requested issue.", {
+            issue: s.nullable(issueSchema),
+            raw: rawSchema,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "list_comments",
+        operationType: "read",
+        description: "List the comments on one Linear issue through Linear's MCP list_comments tool.",
+        requiredScopes: readScope,
+        inputSchema: s.requiredObject("The issue whose comments to read.", {
+            issueId: s.nonEmptyString("Issue ID or human identifier such as ENG-123."),
+        }),
+        outputSchema: s.requiredObject("Comments on the issue.", {
+            comments: s.array("Comments as returned, oldest first when Linear orders them.", commentSchema),
+            raw: rawSchema,
+        }),
+    }),
+];

package/src/providers/linear_mcp/endpoints.d.ts

@@ -0,0 +1,3 @@
+/** Linear's official remote MCP server (RFC 8707 resource) and its OAuth authorization server. */
+export declare const linearMcpEndpoint = "https://mcp.linear.app/mcp";
+export declare const linearMcpIssuer = "https://mcp.linear.app";

package/src/providers/linear_mcp/endpoints.js

@@ -0,0 +1,3 @@
+/** Linear's official remote MCP server (RFC 8707 resource) and its OAuth authorization server. */
+export const linearMcpEndpoint = "https://mcp.linear.app/mcp";
+export const linearMcpIssuer = "https://mcp.linear.app";

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

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

package/src/providers/linear_mcp/executors.js

@@ -0,0 +1,9 @@
+import { defineOAuthProviderExecutors } from "../provider-runtime.js";
+import { linearMcpActionHandlers, validateLinearMcpCredential } from "./runtime-mcp.js";
+const service = "linear_mcp";
+export const executors = defineOAuthProviderExecutors(service, linearMcpActionHandlers, {
+    skipDnsValidation: true,
+});
+export const credentialValidators = {
+    oauth2: validateLinearMcpCredential,
+};

package/src/providers/linear_mcp/runtime-mcp.d.ts

@@ -0,0 +1,15 @@
+import type { CredentialValidationResult, CredentialValidatorOptions, ResolvedCredential } from "../../core/types.ts";
+import type { OAuthProviderContext, ProviderActionHandlers, ProviderActionSources, ProviderRuntimeHandler } from "../provider-runtime.ts";
+declare const service = "linear_mcp";
+/** The Linear MCP tool behind each action. Sign-in requires every one of them (see the validator). */
+export declare const linearMcpToolsByAction: ProviderActionSources<typeof service, string>;
+export declare const linearMcpActionHandlers: ProviderActionHandlers<typeof service, ProviderRuntimeHandler<OAuthProviderContext>>;
+/**
+ * Validate the OAuth grant against the MCP server: every tool the actions map
+ * must be listed (a rename shows up here, at sign-in, never mid-poll), then the
+ * self tool supplies the profile with the same viewer ID the GraphQL API reports.
+ */
+export declare function validateLinearMcpCredential(credential: Extract<ResolvedCredential, {
+    authType: "oauth2";
+}>, options: CredentialValidatorOptions): Promise<CredentialValidationResult>;
+export {};