@oomol-lab/open-connector 1.6.5 → 1.8.0

package/src/providers/linear/trigger-on-issue-changed.js

@@ -0,0 +1,215 @@
+import { isJsonObject } from "../../triggers/common/json.js";
+import { eventsPollOutputs, PermanentPollError, PollConnectionError, TransientPollError, } from "../../triggers/common/poll.js";
+import { snapshot, uuidPattern } from "./trigger-on-issue-changed.definition.js";
+const uuid = new RegExp(uuidPattern);
+const overlapMs = 60_000;
+const pageSize = 50;
+export const linearIssueChanged = {
+    buildOutputs: eventsPollOutputs,
+    snapshot,
+    configOptions: options,
+    async poll(context) {
+        const teamId = typeof context.config.teamId == "string" ? context.config.teamId.toLowerCase() : context.config.teamId;
+        const stateIds = context.config.stateIds;
+        if (typeof teamId != "string" ||
+            !uuid.test(teamId) ||
+            !Array.isArray(stateIds) ||
+            stateIds.length > 50 ||
+            stateIds.some((name) => typeof name != "string" || !uuid.test(name)))
+            throw new PermanentPollError("Linear Issue configuration is invalid.");
+        if (context.checkpoint == null) {
+            const data = await query(context, "query LinearTeam($teamId: String!) { team(id: $teamId) { id } }", { teamId });
+            requireTeam(data.team, teamId);
+            const startedAt = context.now.toISOString();
+            return { checkpoint: { startedAt, since: startedAt }, events: [] };
+        }
+        const checkpoint = readCheckpoint(context.checkpoint);
+        const until = checkpoint.until ?? new Date(Math.max(context.now.getTime(), Date.parse(checkpoint.since))).toISOString();
+        const since = new Date(Math.max(Date.parse(checkpoint.startedAt), Date.parse(checkpoint.since) - overlapMs)).toISOString();
+        const data = await query(context, `query LinearIssueChanges($teamId: String!, $filter: IssueFilter!, $after: String) {
+      team(id: $teamId) {
+        id
+        issues(first: ${pageSize}, after: $after, orderBy: updatedAt, includeArchived: true, filter: $filter) {
+          nodes { id identifier title url createdAt updatedAt state { id name type } }
+          pageInfo { hasNextPage endCursor }
+        }
+      }
+    }`, {
+            teamId,
+            after: checkpoint.after ?? null,
+            filter: {
+                updatedAt: { gte: since, lte: until },
+                ...(stateIds.length == 0 ? {} : { state: { id: { in: stateIds } } }),
+            },
+        });
+        const team = requireTeam(data.team, teamId);
+        const page = team.issues;
+        if (!isJsonObject(page) ||
+            !Array.isArray(page.nodes) ||
+            page.nodes.length > pageSize ||
+            !isJsonObject(page.pageInfo) ||
+            typeof page.pageInfo.hasNextPage != "boolean") {
+            throw new TransientPollError("Linear returned an invalid Issue page.");
+        }
+        const { hasNextPage, endCursor } = page.pageInfo;
+        if (hasNextPage &&
+            (typeof endCursor != "string" ||
+                endCursor.length == 0 ||
+                endCursor.length > 4096 ||
+                endCursor == checkpoint.after ||
+                page.nodes.length == 0)) {
+            throw new TransientPollError("Linear returned an invalid continuation cursor.");
+        }
+        const events = page.nodes.map((value) => {
+            if (!isJsonObject(value) ||
+                typeof value.id != "string" ||
+                !uuid.test(value.id) ||
+                typeof value.identifier != "string" ||
+                value.identifier.length == 0 ||
+                typeof value.title != "string" ||
+                typeof value.url != "string" ||
+                !timestamp(value.createdAt) ||
+                !timestamp(value.updatedAt) ||
+                Date.parse(value.createdAt) > Date.parse(value.updatedAt) ||
+                Date.parse(value.updatedAt) < Date.parse(since) ||
+                Date.parse(value.updatedAt) > Date.parse(until) ||
+                !isJsonObject(value.state) ||
+                typeof value.state.id != "string" ||
+                !uuid.test(value.state.id) ||
+                typeof value.state.name != "string" ||
+                typeof value.state.type != "string" ||
+                (stateIds.length > 0 && !stateIds.includes(value.state.id)))
+                throw new TransientPollError("Linear returned an invalid Issue.");
+            return {
+                dedupeKey: `${value.id}:${value.updatedAt}`,
+                payload: {
+                    id: value.id,
+                    identifier: value.identifier,
+                    title: value.title,
+                    url: value.url,
+                    teamId,
+                    createdAt: value.createdAt,
+                    updatedAt: value.updatedAt,
+                    state: { id: value.state.id, name: value.state.name, type: value.state.type },
+                },
+            };
+        });
+        return {
+            checkpoint: hasNextPage
+                ? { ...checkpoint, until, after: endCursor }
+                : { startedAt: checkpoint.startedAt, since: until },
+            events,
+            hasMore: hasNextPage,
+        };
+    },
+};
+function readCheckpoint(value) {
+    if (!isJsonObject(value) ||
+        !timestamp(value.startedAt) ||
+        !timestamp(value.since) ||
+        Date.parse(value.since) < Date.parse(value.startedAt) ||
+        (value.until != null && (!timestamp(value.until) || Date.parse(value.until) < Date.parse(value.since))) ||
+        (value.after != null &&
+            (typeof value.after != "string" || value.after.length == 0 || value.after.length > 4096 || value.until == null)))
+        throw new PermanentPollError("Linear Issue checkpoint is invalid.");
+    return {
+        startedAt: value.startedAt,
+        since: value.since,
+        ...(typeof value.until == "string" ? { until: value.until } : {}),
+        ...(typeof value.after == "string" ? { after: value.after } : {}),
+    };
+}
+function timestamp(value) {
+    return (typeof value == "string" &&
+        value.length <= 40 &&
+        /^\d{4}-\d{2}-\d{2}T/.test(value) &&
+        Number.isFinite(Date.parse(value)));
+}
+function requireTeam(value, teamId) {
+    if (value === null)
+        throw new PermanentPollError("The Linear team is unavailable or not accessible to this Connection.");
+    if (!isJsonObject(value) || value.id !== teamId)
+        throw new TransientPollError("Linear returned an invalid Team.");
+    return value;
+}
+async function query(context, document, variables) {
+    context.signal?.throwIfAborted();
+    const result = await context.connector.execute({ endpoint: "/graphql", method: "POST", body: { query: document, variables } }, context.signal);
+    context.signal?.throwIfAborted();
+    if (result.status == 401 || result.status == 403)
+        throw new PollConnectionError("Linear Issue access requires authorization.");
+    if (result.status == 429)
+        throw new TransientPollError("Linear Issue checks were rate limited.");
+    const body = result.data;
+    if (isJsonObject(body) && Array.isArray(body.errors) && body.errors.length > 0) {
+        const codes = new Set(body.errors.flatMap((error) => isJsonObject(error) && isJsonObject(error.extensions) ? [error.extensions.code] : []));
+        if (codes.has("UNAUTHENTICATED") || codes.has("FORBIDDEN") || codes.has("AUTHENTICATION_ERROR")) {
+            throw new PollConnectionError("Linear Issue access requires authorization.");
+        }
+        if (codes.has("RATELIMITED"))
+            throw new TransientPollError("Linear Issue checks were rate limited.");
+        if (codes.has("GRAPHQL_VALIDATION_FAILED") || codes.has("BAD_USER_INPUT"))
+            throw new PermanentPollError("Linear rejected the Issue query configuration.");
+        throw new TransientPollError("Linear Issue query failed; progress was retained.");
+    }
+    if (result.status != 200 ||
+        !isJsonObject(body) ||
+        !isJsonObject(body.data) ||
+        (body.errors != null && !Array.isArray(body.errors))) {
+        throw new TransientPollError(`Linear returned an invalid query response (HTTP ${result.status}).`);
+    }
+    return body.data;
+}
+async function options(context) {
+    const { field, config } = context;
+    if (field != "teamId" && field != "stateIds")
+        throw new PermanentPollError("Unknown Linear configuration field.");
+    if (field == "stateIds" && (typeof config.teamId != "string" || !uuid.test(config.teamId)))
+        throw new PermanentPollError("Select a Linear Team first.");
+    const choices = [];
+    const cursors = new Set();
+    let after = null;
+    for (let page = 0; page < 10; page++) {
+        const data = await query(context, field == "teamId"
+            ? "query LinearTeams($after: String) { teams(first: 100, after: $after) { nodes { id name key } pageInfo { hasNextPage endCursor } } }"
+            : "query LinearStates($teamId: String!, $after: String) { team(id: $teamId) { id states(first: 100, after: $after) { nodes { id name color position } pageInfo { hasNextPage endCursor } } } }", { after, ...(field == "teamId" ? {} : { teamId: config.teamId }) });
+        const values = field == "teamId" ? data.teams : requireTeam(data.team, String(config.teamId)).states;
+        if (!isJsonObject(values) ||
+            !Array.isArray(values.nodes) ||
+            values.nodes.length > 100 ||
+            !isJsonObject(values.pageInfo) ||
+            typeof values.pageInfo.hasNextPage != "boolean") {
+            throw new TransientPollError("Linear returned invalid configuration options.");
+        }
+        for (const item of values.nodes) {
+            if (!isJsonObject(item) ||
+                typeof item.id != "string" ||
+                !uuid.test(item.id) ||
+                typeof item.name != "string" ||
+                item.name.length == 0 ||
+                (field == "teamId"
+                    ? typeof item.key != "string"
+                    : typeof item.color != "string" || !/^#[0-9a-fA-F]{6}$/.test(item.color))) {
+                throw new TransientPollError("Linear returned an invalid configuration option.");
+            }
+            choices.push({
+                value: item.id,
+                label: field == "teamId" ? `${item.name} (${item.key})` : item.name,
+                ...(field == "stateIds" ? { color: String(item.color) } : {}),
+            });
+        }
+        if (!values.pageInfo.hasNextPage)
+            return choices;
+        const cursor = values.pageInfo.endCursor;
+        if (typeof cursor != "string" ||
+            cursor.length == 0 ||
+            cursor.length > 4096 ||
+            cursors.has(cursor) ||
+            values.nodes.length == 0) {
+            throw new TransientPollError("Linear returned an invalid options cursor.");
+        }
+        cursors.add(cursor);
+        after = cursor;
+    }
+    throw new PermanentPollError("The Linear options list exceeds the supported limit of 1000 entries.");
+}

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 {};

package/src/providers/linear_mcp/runtime-mcp.js

@@ -0,0 +1,238 @@
+import { ProtocolError, SdkHttpError, UnauthorizedError } from "@modelcontextprotocol/client";
+import { compactObject, looseArray, optionalBoolean, optionalInteger, optionalRawString, optionalRecord, optionalString, pickOptionalString, } from "../../core/cast.js";
+import { withMcpClient } from "../mcp-client.js";
+import { providerResponseError, providerUserAgent, ProviderRequestError, requiredInputString, runProviderRequest, } from "../provider-runtime.js";
+import { linearMcpEndpoint } from "./endpoints.js";
+const service = "linear_mcp";
+/** The Linear MCP tool behind each action. Sign-in requires every one of them (see the validator). */
+export const linearMcpToolsByAction = {
+    get_self: "get_user",
+    list_issues: "list_issues",
+    get_issue: "get_issue",
+    list_comments: "list_comments",
+};
+const humanIdentifier = /^[A-Z][A-Z0-9]*-\d+$/;
+const uuidIdentifier = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const truncationMarker = /\(truncated\b/i;
+const maxToolListPages = 20;
+export const linearMcpActionHandlers = {
+    async get_self(_input, context) {
+        const result = await callLinearMcpTool(context, "execute", linearMcpToolsByAction.get_self, { query: "me" });
+        return { user: parseLinearMcpUser(result.payload) ?? null, raw: result.text };
+    },
+    async list_issues(input, context) {
+        const result = await callLinearMcpTool(context, "execute", linearMcpToolsByAction.list_issues, compactObject({
+            updatedAt: optionalString(input.updatedAt),
+            orderBy: optionalString(input.orderBy),
+            limit: optionalInteger(input.limit),
+            cursor: optionalString(input.cursor),
+        }));
+        return { ...parseLinearMcpIssuePage(result.payload), raw: result.text };
+    },
+    async get_issue(input, context) {
+        const id = requiredInputString(input.id, "id");
+        const result = await callLinearMcpTool(context, "execute", linearMcpToolsByAction.get_issue, { id });
+        return { issue: parseLinearMcpIssue(result.payload) ?? null, raw: result.text };
+    },
+    async list_comments(input, context) {
+        const issueId = requiredInputString(input.issueId, "issueId");
+        const result = await callLinearMcpTool(context, "execute", linearMcpToolsByAction.list_comments, { issueId });
+        return { comments: parseLinearMcpComments(result.payload), raw: result.text };
+    },
+};
+/**
+ * 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 async function validateLinearMcpCredential(credential, options) {
+    const context = { accessToken: credential.accessToken, fetcher: options.fetcher, signal: options.signal };
+    return withLinearMcpClient(context, "validate", async (client, signal) => {
+        const available = await listLinearMcpToolNames(client, signal);
+        const missing = Object.values(linearMcpToolsByAction).filter((name) => !available.has(name));
+        if (missing.length > 0) {
+            throw new ProviderRequestError(502, `Linear MCP did not expose the ${missing.join(", ")} tool${missing.length > 1 ? "s" : ""} this connector needs; Linear may have renamed ${missing.length > 1 ? "them" : "it"}.`);
+        }
+        const result = readLinearMcpToolResult(linearMcpToolsByAction.get_self, await client.callTool({ name: linearMcpToolsByAction.get_self, arguments: { query: "me" } }, { signal }));
+        const user = parseLinearMcpUser(result.payload);
+        if (!user)
+            throw providerResponseError("Linear MCP did not return the signed-in user.");
+        return {
+            profile: { accountId: user.id, displayName: user.displayName ?? user.name ?? user.email ?? user.id },
+            grantedScopes: optionalString(credential.metadata.scope)?.split(" ") ?? [],
+            metadata: { mcpEndpoint: linearMcpEndpoint, discoveredToolCount: available.size },
+        };
+    });
+}
+async function listLinearMcpToolNames(client, signal) {
+    const names = new Set();
+    let cursor;
+    for (let page = 0; page < maxToolListPages; page += 1) {
+        const listed = await client.listTools(cursor ? { cursor } : {}, { signal });
+        for (const tool of listed.tools)
+            names.add(tool.name);
+        cursor = optionalString(listed.nextCursor);
+        if (!cursor)
+            break;
+    }
+    return names;
+}
+/** Call one tool in a fresh MCP session and return its text and parsed payload. */
+function callLinearMcpTool(context, phase, name, args) {
+    return withLinearMcpClient(context, phase, async (client, signal) => readLinearMcpToolResult(name, await client.callTool({ name, arguments: args }, { signal })));
+}
+/**
+ * Join the text blocks as `text` and read the JSON they carry as `payload`
+ * (structured content wins when the server sends it). Text that is not JSON
+ * is not an error: the typed fields stay empty and `raw` still reaches the caller.
+ */
+function readLinearMcpToolResult(name, result) {
+    if ("toolResult" in result) {
+        return { text: JSON.stringify(result.toolResult), payload: result.toolResult };
+    }
+    if (result.isError)
+        throw new ProviderRequestError(502, `Linear MCP tool ${name} failed.`, result);
+    const text = looseArray(result.content)
+        .map((block) => optionalRecord(block))
+        .filter((block) => block?.type === "text")
+        .map((block) => optionalRawString(block?.text) ?? "")
+        .join("\n");
+    return { text, payload: optionalRecord(result.structuredContent) ?? parseJsonText(text) };
+}
+function parseJsonText(text) {
+    const trimmed = text.trim();
+    if (!trimmed.startsWith("{") && !trimmed.startsWith("["))
+        return undefined;
+    try {
+        return JSON.parse(trimmed);
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseLinearMcpUser(payload) {
+    const record = optionalRecord(payload);
+    const user = record && (optionalRecord(record.user) ?? optionalRecord(record.viewer) ?? record);
+    const id = user && pickOptionalString(user, "id", "uuid");
+    if (!user || !id)
+        return undefined;
+    return {
+        id,
+        email: pickOptionalString(user, "email"),
+        displayName: pickOptionalString(user, "displayName", "display_name"),
+        name: pickOptionalString(user, "name"),
+    };
+}
+function parseLinearMcpIssuePage(payload) {
+    const record = optionalRecord(payload);
+    const items = Array.isArray(payload) ? payload : looseArray(record?.issues ?? record?.nodes ?? record?.results);
+    const issues = items.map(parseLinearMcpIssue).filter((issue) => issue !== undefined);
+    const cursor = record ? (pickOptionalString(record, "cursor", "nextCursor", "endCursor") ?? null) : null;
+    const hasNextPage = (record && (optionalBoolean(record.hasNextPage) ?? optionalBoolean(record.hasMore))) ?? cursor !== null;
+    return { issues, hasNextPage, cursor };
+}
+function parseLinearMcpIssue(value) {
+    const record = optionalRecord(value);
+    const issue = record && (optionalRecord(record.issue) ?? record);
+    const id = issue && pickOptionalString(issue, "id", "identifier", "uuid");
+    if (!issue || !id)
+        return undefined;
+    const description = optionalRawString(issue.description);
+    const assignee = optionalRecord(issue.assignee);
+    const creator = optionalRecord(issue.creator);
+    return {
+        id,
+        identifier: pickOptionalString(issue, "identifier") ?? (humanIdentifier.test(id) ? id : undefined),
+        uuid: pickOptionalString(issue, "uuid") ?? (uuidIdentifier.test(id) ? id : undefined),
+        title: optionalRawString(issue.title),
+        description,
+        descriptionTruncated: description === undefined ? undefined : truncationMarker.test(description),
+        url: pickOptionalString(issue, "url"),
+        state: labelOf(issue.state ?? issue.status),
+        priority: issue.priority,
+        assignee: labelOf(issue.assignee),
+        assigneeId: assignee && pickOptionalString(assignee, "id"),
+        creator: labelOf(issue.creator),
+        creatorId: creator && pickOptionalString(creator, "id"),
+        team: labelOf(issue.team),
+        project: labelOf(issue.project),
+        labels: parseLabels(issue.labels),
+        createdAt: pickOptionalString(issue, "createdAt", "created_at"),
+        updatedAt: pickOptionalString(issue, "updatedAt", "updated_at"),
+        archivedAt: pickOptionalString(issue, "archivedAt", "archived_at"),
+        completedAt: pickOptionalString(issue, "completedAt", "completed_at"),
+        dueDate: pickOptionalString(issue, "dueDate", "due_date"),
+    };
+}
+function parseLinearMcpComments(payload) {
+    const record = optionalRecord(payload);
+    const items = Array.isArray(payload) ? payload : looseArray(record?.comments ?? record?.nodes);
+    return items.flatMap((item) => {
+        const comment = optionalRecord(item);
+        const id = comment && pickOptionalString(comment, "id");
+        if (!comment || !id)
+            return [];
+        const user = optionalRecord(comment.user);
+        return [
+            {
+                id,
+                body: optionalRawString(comment.body),
+                user: labelOf(comment.user),
+                userId: user && pickOptionalString(user, "id"),
+                createdAt: pickOptionalString(comment, "createdAt", "created_at"),
+                updatedAt: pickOptionalString(comment, "updatedAt", "updated_at"),
+                url: pickOptionalString(comment, "url"),
+            },
+        ];
+    });
+}
+/** A name for a value Linear may return as a string or as an object such as `{ id, name }`. */
+function labelOf(value) {
+    const record = optionalRecord(value);
+    if (record)
+        return pickOptionalString(record, "name", "displayName", "title", "key", "id");
+    return optionalString(value);
+}
+function parseLabels(value) {
+    if (!Array.isArray(value))
+        return undefined;
+    return value.flatMap((label) => {
+        const name = labelOf(label);
+        return name ? [name] : [];
+    });
+}
+function withLinearMcpClient(context, phase, run) {
+    return runProviderRequest({ signal: context.signal, label: "Linear MCP" }, (signal) => withMcpClient({
+        endpoint: new URL(linearMcpEndpoint),
+        transport: "streamable_http",
+        fetcher: context.fetcher,
+        headers: { authorization: `Bearer ${context.accessToken}`, "user-agent": providerUserAgent },
+        redirect: "manual",
+        signal,
+        mapError: (error) => mapLinearMcpError(error, phase),
+    }, (client) => run(client, signal)));
+}
+/**
+ * A rejected token is a bad credential (400) while validating and an expired
+ * authorization (401) while executing; other SDK failures keep a 4xx status or
+ * become 502. Aborts and unknown errors pass through for the request wrapper.
+ */
+function mapLinearMcpError(error, phase) {
+    if (error instanceof ProviderRequestError)
+        return error;
+    if (error instanceof UnauthorizedError)
+        return credentialError(phase);
+    if (error instanceof SdkHttpError) {
+        const status = error.status;
+        if (status === 401 || status === 403)
+            return credentialError(phase);
+        return new ProviderRequestError(400 <= status && status < 500 ? status : 502, `Linear MCP request failed: ${error.message}`, error);
+    }
+    if (error instanceof ProtocolError) {
+        return new ProviderRequestError(502, `Linear MCP request failed: ${error.message}`, error);
+    }
+    return error;
+}
+function credentialError(phase) {
+    return new ProviderRequestError(phase === "validate" ? 400 : 401, "Linear MCP credential is invalid or expired; reconnect Linear.");
+}

package/src/providers/lingxing_mcp/runtime.js

@@ -174,7 +174,7 @@ async function withLingxingMcpClient(context, run) {
         transport: "streamable_http",
         fetcher: createLingxingRateLimitedFetch(context.fetcher, hashLingxingRateLimitKey(context)),
         headers,
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         mapError: mapLingxingMcpError,
     }, run);

package/src/providers/mcdonalds_cn_mcp/runtime.js

@@ -65,7 +65,7 @@ async function withMcdonaldsCnMcpClient(context, run) {
         transport: "streamable_http",
         fetcher: context.fetcher,
         headers,
-        redirect: "error",
+        redirect: "manual",
         signal: context.signal,
         protocolVersion: "legacy",
         mapError: mapMcdonaldsCnMcpError,