@oomol-lab/open-connector 1.9.0 → 1.9.1

package/src/providers/kaonavi/runtime.js

@@ -0,0 +1,69 @@
+import { sha256Hex } from "../../core/aws-sigv4.js";
+import { looseArray, recordOrEmpty, optionalString, optionalNumber } from "../../core/cast.js";
+import { basicAuthorizationHeader, isAbortLikeError, ProviderRequestError, requiredInputString, requiredResponseRecord, runProviderRequest, providerInputError, providerResponseError, } from "../provider-runtime.js";
+export const kaonaviBaseUrl = "https://api.kaonavi.jp/api/v2.0";
+const tokens = new Map();
+export async function readKaonaviResponse(response) {
+    const code = response.status === 429 ? "rate_limited" : "provider_error";
+    let payload;
+    try {
+        payload = await response.json();
+    }
+    catch (error) {
+        if (isAbortLikeError(error))
+            throw error;
+        throw new ProviderRequestError(response.ok ? 502 : response.status, "Kaonavi returned a non-JSON response", undefined, code);
+    }
+    if (!response.ok) {
+        const messages = looseArray(recordOrEmpty(payload).errors).map(optionalString).filter(Boolean);
+        throw new ProviderRequestError(response.status, messages.join("; ") || `Kaonavi request failed (${response.status})`, undefined, code);
+    }
+    return requiredResponseRecord(payload, "Kaonavi response");
+}
+export async function getKaonaviToken(values, fetcher, signal, fresh = false) {
+    const key = requiredInputString(values.consumerKey, "consumerKey");
+    const secret = requiredInputString(values.consumerSecret, "consumerSecret");
+    if (key.includes(":"))
+        throw providerInputError("consumerKey must not contain a colon");
+    const cacheKey = sha256Hex(JSON.stringify([key, secret]));
+    const existing = fresh ? undefined : tokens.get(cacheKey);
+    if (existing) {
+        const token = await existing;
+        if (token.expiresAt > Date.now())
+            return token.value;
+        if (tokens.get(cacheKey) !== existing)
+            return getKaonaviToken(values, fetcher, signal);
+    }
+    const pending = runProviderRequest({ label: "Kaonavi token", signal }, async (requestSignal) => {
+        const response = await fetcher(`${kaonaviBaseUrl}/token`, {
+            method: "POST",
+            signal: requestSignal,
+            headers: {
+                authorization: basicAuthorizationHeader(`${key}:${secret}`),
+                "content-type": "application/x-www-form-urlencoded;charset=UTF-8",
+                accept: "application/json",
+            },
+            body: new URLSearchParams({ grant_type: "client_credentials" }).toString(),
+        });
+        const payload = await readKaonaviResponse(response);
+        const value = optionalString(payload.access_token);
+        const ttl = optionalNumber(payload.expire_in);
+        if (!value?.trim() || ttl === undefined || !Number.isFinite(ttl) || ttl <= 0)
+            throw providerResponseError("Kaonavi token response is missing a valid access_token or expire_in");
+        return { value, expiresAt: Date.now() + Math.max(0, ttl * 1000 - 60_000) };
+    });
+    tokens.set(cacheKey, pending);
+    if (tokens.size > 1024) {
+        const oldest = tokens.keys().next().value;
+        if (oldest !== undefined)
+            tokens.delete(oldest);
+    }
+    try {
+        return (await pending).value;
+    }
+    catch (error) {
+        if (tokens.get(cacheKey) === pending)
+            tokens.delete(cacheKey);
+        throw error;
+    }
+}

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

@@ -44,4 +44,18 @@ export interface LinearMcpComment {
     updatedAt?: string;
     url?: string;
 }
+/**
+ * Typed fields lifted from one Linear MCP record that names a thing: a team, a
+ * project, a workflow state or a label. The list tools answer records of
+ * different shapes; only the id is required and the rest is best effort.
+ */
+export interface LinearMcpNamedRecord {
+    id: string;
+    name?: string;
+    key?: string;
+    type?: string;
+    color?: string;
+    url?: string;
+    state?: string;
+}
 export declare const linearMcpActions: ActionDefinition[];

package/src/providers/linear_mcp/actions.js

@@ -2,6 +2,7 @@ import { s } from "../../core/json-schema.js";
 import { defineProviderAction } from "../../core/provider-definition.js";
 const service = "linear_mcp";
 const readScope = ["read"];
+const writeScope = ["write"];
 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."),
@@ -41,6 +42,54 @@ const commentSchema = s.looseObject("A Linear issue comment.", {
     updatedAt: s.optional(s.string("Last edit time, when returned.")),
     url: s.optional(s.string("Link to the comment in Linear.")),
 });
+const namedRecordSchema = s.looseObject("A team, project, workflow state or label as Linear MCP lists it. Typed fields are lifted when present; the rest is only in the action's raw text.", {
+    id: s.nonEmptyString("Record ID as Linear MCP returned it."),
+    name: s.optional(s.string("Display name.")),
+    key: s.optional(s.string("Team key such as ENG, when the record is a team.")),
+    type: s.optional(s.string("Workflow state type such as started or completed, when the record is a state.")),
+    color: s.optional(s.string("Color, when the record is a label.")),
+    url: s.optional(s.string("Link to the record in Linear, when returned.")),
+    state: s.optional(s.string("Project state, when the record is a project.")),
+});
+const issueFields = {
+    title: s.nonEmptyString("Issue title."),
+    description: s.string("Issue description in Markdown."),
+    team: s.nonEmptyString("Team key, name or ID the issue belongs to."),
+    assignee: s.string("Assignee as a user ID, name or email, or me for the signed-in user."),
+    state: s.string("Workflow state name or ID."),
+    priority: s.integer("Priority as Linear numbers it: 0 none, 1 urgent, 2 high, 3 medium, 4 low.", {
+        minimum: 0,
+        maximum: 4,
+    }),
+    labels: s.stringArray("Label names or IDs."),
+    project: s.string("Project name or ID."),
+    dueDate: s.string("Due date as YYYY-MM-DD."),
+    parentId: s.string("Parent issue ID or identifier, for a sub-issue."),
+    estimate: s.integer("Estimate on the team's scale."),
+};
+const optionalIssueFields = [
+    "description",
+    "assignee",
+    "state",
+    "priority",
+    "labels",
+    "project",
+    "dueDate",
+    "parentId",
+    "estimate",
+];
+const createIssueInputSchema = s.object("Fields forwarded to Linear's MCP save_issue tool without an id, which creates the issue. Keys this schema does not name pass through as given and Linear's server validates them.", issueFields, { optional: optionalIssueFields, additionalProperties: true });
+const updateIssueInputSchema = s.object("Fields forwarded to Linear's MCP save_issue tool with an id, which updates the issue. Only the fields given change; keys this schema does not name pass through as given.", { id: s.nonEmptyString("Issue ID or human identifier such as ENG-123, as returned by list_issues."), ...issueFields }, { optional: ["title", "team", ...optionalIssueFields], additionalProperties: true });
+const createCommentInputSchema = s.object("Fields forwarded to Linear's MCP save_comment tool without an id, which creates the comment.", {
+    issueId: s.nonEmptyString("Issue ID or human identifier such as ENG-123."),
+    body: s.nonEmptyString("Comment body in Markdown."),
+    parentId: s.string("Comment ID to reply to, for a threaded reply."),
+}, { optional: ["parentId"], additionalProperties: true });
+const listProjectsInputSchema = s.object("Filters forwarded to Linear's MCP list_projects tool. Keys this schema does not name pass through as given.", {
+    team: s.nonEmptyString("Team key, name or ID whose projects to list."),
+    limit: s.integer("Maximum number of projects to return on this page.", { minimum: 1, maximum: 250 }),
+    cursor: s.nonEmptyString("Cursor returned by the previous page of the same query."),
+}, { optional: ["team", "limit", "cursor"], additionalProperties: true });
 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."),
@@ -99,4 +148,89 @@ export const linearMcpActions = [
             raw: rawSchema,
         }),
     }),
+    defineProviderAction(service, {
+        name: "list_teams",
+        operationType: "read",
+        description: "List the teams of the connected Linear workspace through Linear's MCP list_teams tool: the keys and IDs the issue tools take as team.",
+        requiredScopes: readScope,
+        followUpActions: ["linear_mcp.list_issue_statuses", "linear_mcp.list_issue_labels", "linear_mcp.create_issue"],
+        inputSchema: s.object({}),
+        outputSchema: s.requiredObject("The teams.", {
+            teams: s.array("Teams as returned.", namedRecordSchema),
+            raw: rawSchema,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "list_projects",
+        operationType: "read",
+        description: "List Linear projects through Linear's MCP list_projects tool, optionally for one team, with cursor pagination.",
+        requiredScopes: readScope,
+        inputSchema: listProjectsInputSchema,
+        outputSchema: s.requiredObject("One page of projects.", {
+            projects: s.array("Projects on this page.", namedRecordSchema),
+            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: "list_issue_statuses",
+        operationType: "read",
+        description: "List one team's workflow states through Linear's MCP list_issue_statuses tool: the names the issue tools take as state.",
+        requiredScopes: readScope,
+        inputSchema: s.requiredObject("The team whose workflow states to list.", {
+            team: s.nonEmptyString("Team key, name or ID."),
+        }),
+        outputSchema: s.requiredObject("The workflow states.", {
+            statuses: s.array("States as returned.", namedRecordSchema),
+            raw: rawSchema,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "list_issue_labels",
+        operationType: "read",
+        description: "List issue labels through Linear's MCP list_issue_labels tool, for the workspace or one team.",
+        requiredScopes: readScope,
+        inputSchema: s.object("Optional team filter.", { team: s.nonEmptyString("Team key, name or ID; omitted, the workspace's labels.") }, { optional: ["team"] }),
+        outputSchema: s.requiredObject("The labels.", {
+            labels: s.array("Labels as returned.", namedRecordSchema),
+            raw: rawSchema,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "create_issue",
+        operationType: "write",
+        description: "Create a Linear issue through Linear's MCP save_issue tool. Needs the write scope on the grant; an id in the input is dropped so this never updates an existing issue.",
+        requiredScopes: writeScope,
+        followUpActions: ["linear_mcp.get_issue", "linear_mcp.create_comment"],
+        inputSchema: createIssueInputSchema,
+        outputSchema: s.requiredObject("The created issue.", {
+            issue: s.nullable(issueSchema),
+            raw: rawSchema,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "update_issue",
+        operationType: "write",
+        description: "Update a Linear issue through Linear's MCP save_issue tool with its id: the title, description, team, assignee, state, priority, labels, project, due date, parent or estimate. Needs the write scope on the grant.",
+        requiredScopes: writeScope,
+        followUpActions: ["linear_mcp.get_issue"],
+        inputSchema: updateIssueInputSchema,
+        outputSchema: s.requiredObject("The updated issue.", {
+            issue: s.nullable(issueSchema),
+            raw: rawSchema,
+        }),
+    }),
+    defineProviderAction(service, {
+        name: "create_comment",
+        operationType: "write",
+        description: "Comment on a Linear issue through Linear's MCP save_comment tool, optionally as a reply to another comment. Needs the write scope on the grant.",
+        requiredScopes: writeScope,
+        followUpActions: ["linear_mcp.list_comments"],
+        inputSchema: createCommentInputSchema,
+        outputSchema: s.requiredObject("The created comment.", {
+            comment: s.nullable(commentSchema),
+            raw: rawSchema,
+        }),
+    }),
 ];

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

@@ -1,7 +1,13 @@
 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). */
+/**
+ * The Linear MCP tool behind each action. Sign-in requires the four reads the
+ * connector was built on (linearMcpSignInTools, the validator); the reference
+ * reads and the writes are called as they are and fail on their own when the
+ * server does not list them. save_issue and save_comment create without an id
+ * and update with one, so two actions share each.
+ */
 export declare const linearMcpToolsByAction: ProviderActionSources<typeof service, string>;
 export declare const linearMcpActionHandlers: ProviderActionHandlers<typeof service, ProviderRuntimeHandler<OAuthProviderContext>>;
 /**

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

@@ -4,24 +4,48 @@ 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). */
+/**
+ * The Linear MCP tool behind each action. Sign-in requires the four reads the
+ * connector was built on (linearMcpSignInTools, the validator); the reference
+ * reads and the writes are called as they are and fail on their own when the
+ * server does not list them. save_issue and save_comment create without an id
+ * and update with one, so two actions share each.
+ */
 export const linearMcpToolsByAction = {
     get_self: "get_user",
     list_issues: "list_issues",
     get_issue: "get_issue",
     list_comments: "list_comments",
+    list_teams: "list_teams",
+    list_projects: "list_projects",
+    list_issue_statuses: "list_issue_statuses",
+    list_issue_labels: "list_issue_labels",
+    create_issue: "save_issue",
+    update_issue: "save_issue",
+    create_comment: "save_comment",
 };
+/**
+ * The tools every grant must serve at sign-in. The writes stay out on purpose: a
+ * read-only grant, the default, or an older server may not list them, and a
+ * credential must not be refused for a tool its grant could never call.
+ */
+const linearMcpSignInTools = [
+    linearMcpToolsByAction.get_self,
+    linearMcpToolsByAction.list_issues,
+    linearMcpToolsByAction.get_issue,
+    linearMcpToolsByAction.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" });
+        const result = await callLinearMcpTool(context, 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({
+        const result = await callLinearMcpTool(context, linearMcpToolsByAction.list_issues, compactObject({
             updatedAt: optionalString(input.updatedAt),
             orderBy: optionalString(input.orderBy),
             limit: optionalInteger(input.limit),
@@ -31,15 +55,72 @@ export const linearMcpActionHandlers = {
     },
     async get_issue(input, context) {
         const id = requiredInputString(input.id, "id");
-        const result = await callLinearMcpTool(context, "execute", linearMcpToolsByAction.get_issue, { id });
+        const result = await callLinearMcpTool(context, 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 });
+        const result = await callLinearMcpTool(context, linearMcpToolsByAction.list_comments, { issueId });
         return { comments: parseLinearMcpComments(result.payload), raw: result.text };
     },
+    async list_teams(_input, context) {
+        const result = await callLinearMcpTool(context, linearMcpToolsByAction.list_teams, {});
+        return { teams: parseLinearMcpRecords(result.payload, "teams"), raw: result.text };
+    },
+    async list_projects(input, context) {
+        const result = await callLinearMcpTool(context, linearMcpToolsByAction.list_projects, compactObject(input));
+        return {
+            projects: parseLinearMcpRecords(result.payload, "projects"),
+            ...parseLinearMcpPaging(result.payload),
+            raw: result.text,
+        };
+    },
+    async list_issue_statuses(input, context) {
+        const team = requiredInputString(input.team, "team");
+        const result = await callLinearMcpTool(context, linearMcpToolsByAction.list_issue_statuses, { team });
+        return {
+            statuses: parseLinearMcpRecords(result.payload, "statuses", "states", "workflowStates"),
+            raw: result.text,
+        };
+    },
+    async list_issue_labels(input, context) {
+        const result = await callLinearMcpTool(context, linearMcpToolsByAction.list_issue_labels, compactObject({ team: optionalString(input.team) }));
+        return { labels: parseLinearMcpRecords(result.payload, "labels", "issueLabels"), raw: result.text };
+    },
+    async create_issue(input, context) {
+        const title = requiredInputString(input.title, "title");
+        const team = requiredInputString(input.team, "team");
+        const result = await callLinearMcpTool(context, linearMcpToolsByAction.create_issue, {
+            ...withoutId(input),
+            title,
+            team,
+        });
+        return { issue: parseLinearMcpIssue(result.payload) ?? null, raw: result.text };
+    },
+    async update_issue(input, context) {
+        const id = requiredInputString(input.id, "id");
+        const result = await callLinearMcpTool(context, linearMcpToolsByAction.update_issue, {
+            ...compactObject(input),
+            id,
+        });
+        return { issue: parseLinearMcpIssue(result.payload) ?? null, raw: result.text };
+    },
+    async create_comment(input, context) {
+        const issueId = requiredInputString(input.issueId, "issueId");
+        const body = requiredInputString(input.body, "body");
+        const result = await callLinearMcpTool(context, linearMcpToolsByAction.create_comment, {
+            ...withoutId(input),
+            issueId,
+            body,
+        });
+        return { comment: parseLinearMcpComments(unwrapComment(result.payload))[0] ?? null, raw: result.text };
+    },
 };
+/** The input with any `id` dropped: save_issue and save_comment update when they see one, and a create never does. */
+function withoutId(input) {
+    const { id: _id, ...rest } = compactObject(input);
+    return rest;
+}
 /**
  * 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
@@ -47,9 +128,9 @@ export const linearMcpActionHandlers = {
  */
 export async function validateLinearMcpCredential(credential, options) {
     const context = { accessToken: credential.accessToken, fetcher: options.fetcher, signal: options.signal };
-    return withLinearMcpClient(context, "validate", async (client, signal) => {
+    return withLinearMcpClient(context, async (client, signal) => {
         const available = await listLinearMcpToolNames(client, signal);
-        const missing = Object.values(linearMcpToolsByAction).filter((name) => !available.has(name));
+        const missing = linearMcpSignInTools.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"}.`);
         }
@@ -78,8 +159,8 @@ async function listLinearMcpToolNames(client, signal) {
     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 })));
+function callLinearMcpTool(context, name, args) {
+    return withLinearMcpClient(context, 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`
@@ -127,9 +208,49 @@ 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);
+    return { issues, ...parseLinearMcpPaging(payload) };
+}
+/** The page bounds of a list answer: a cursor under any of its names, and whether another page follows. */
+function parseLinearMcpPaging(payload) {
+    const record = optionalRecord(payload);
     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 };
+    return { hasNextPage, cursor };
+}
+/**
+ * The records of a list answer — the first of the named arrays, the answer
+ * itself when it is an array, else `nodes` or `results` — each typed when it
+ * carries an id: a team, a project, a workflow state or a label.
+ */
+function parseLinearMcpRecords(payload, ...keys) {
+    const record = optionalRecord(payload);
+    const named = keys.map((key) => record?.[key]).find((value) => Array.isArray(value));
+    const items = Array.isArray(payload) ? payload : looseArray(named ?? record?.nodes ?? record?.results);
+    return items.flatMap((item) => {
+        const entry = optionalRecord(item);
+        const id = entry && pickOptionalString(entry, "id");
+        if (!entry || !id)
+            return [];
+        return [
+            {
+                id,
+                ...compactObject({
+                    name: pickOptionalString(entry, "name", "title"),
+                    key: pickOptionalString(entry, "key"),
+                    type: pickOptionalString(entry, "type"),
+                    color: pickOptionalString(entry, "color"),
+                    url: pickOptionalString(entry, "url"),
+                    state: labelOf(entry.state ?? entry.status),
+                }),
+            },
+        ];
+    });
+}
+/** A save_comment answer as a one-item list for the comments reader: the comment under `comment`, else the answer itself. */
+function unwrapComment(payload) {
+    const record = optionalRecord(payload);
+    const comment = record && (optionalRecord(record.comment) ?? record);
+    return comment ? [comment] : [];
 }
 function parseLinearMcpIssue(value) {
     const record = optionalRecord(value);
@@ -201,7 +322,7 @@ function parseLabels(value) {
         return name ? [name] : [];
     });
 }
-function withLinearMcpClient(context, phase, run) {
+function withLinearMcpClient(context, run) {
     return runProviderRequest({ signal: context.signal, label: "Linear MCP" }, (signal) => withMcpClient({
         endpoint: new URL(linearMcpEndpoint),
         transport: "streamable_http",
@@ -209,30 +330,21 @@ function withLinearMcpClient(context, phase, run) {
         headers: { authorization: `Bearer ${context.accessToken}`, "user-agent": providerUserAgent },
         redirect: "manual",
         signal,
-        mapError: (error) => mapLinearMcpError(error, phase),
+        mapError: mapLinearMcpError,
     }, (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) {
+// Status alone does not establish that reconnecting can resolve a provider failure.
+function mapLinearMcpError(error) {
     if (error instanceof ProviderRequestError)
         return error;
-    if (error instanceof UnauthorizedError)
-        return credentialError(phase);
+    if (error instanceof UnauthorizedError) {
+        return new ProviderRequestError(401, "Linear MCP authorization request failed.", undefined, "provider_error");
+    }
     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);
+        return new ProviderRequestError(error.status, `Linear MCP request failed with HTTP ${error.status}.`, undefined, error.status === 429 ? "rate_limited" : "provider_error");
     }
     if (error instanceof ProtocolError) {
-        return new ProviderRequestError(502, `Linear MCP request failed: ${error.message}`, error);
+        return new ProviderRequestError(502, `Linear MCP protocol error ${error.code}.`, undefined, "provider_error");
     }
     return error;
 }
-function credentialError(phase) {
-    return new ProviderRequestError(phase === "validate" ? 400 : 401, "Linear MCP credential is invalid or expired; reconnect Linear.");
-}