@elizaos/plugin-linear 2.0.0-beta.1 → 2.0.3-beta.3

package/dist/index.js

@@ -1,3668 +0,0 @@
-// src/index.ts
-import { getConnectorAccountManager, logger as logger14, promoteSubactionsToActions } from "@elizaos/core";
-
-// src/accounts.ts
-var DEFAULT_LINEAR_ACCOUNT_ID = "default";
-var DEFAULT_LINEAR_ACCOUNT_ROLE = "OWNER";
-function nonEmptyString(value) {
-  return typeof value === "string" && value.trim().length > 0 ? value.trim() : undefined;
-}
-function readSetting(runtime, key) {
-  return nonEmptyString(runtime.getSetting(key));
-}
-function normalizeLinearAccountId(value) {
-  return nonEmptyString(value) ?? DEFAULT_LINEAR_ACCOUNT_ID;
-}
-function resolveLinearAccountId(runtime, options) {
-  const requested = nonEmptyString(options?.accountId) ?? nonEmptyString(options?.linearAccountId);
-  if (requested)
-    return requested;
-  const configuredDefault = readSetting(runtime, "LINEAR_DEFAULT_ACCOUNT_ID") ?? readSetting(runtime, "LINEAR_ACCOUNT_ID");
-  const accounts = readLinearAccounts(runtime);
-  const defaultAccount = resolveLinearDefaultAccount(accounts, configuredDefault);
-  return defaultAccount?.accountId ?? normalizeLinearAccountId(configuredDefault);
-}
-function parseAccountsJson(raw) {
-  if (!raw)
-    return [];
-  try {
-    const parsed = JSON.parse(raw);
-    if (Array.isArray(parsed)) {
-      return parsed.filter((item) => Boolean(item) && typeof item === "object" && !Array.isArray(item));
-    }
-    if (parsed && typeof parsed === "object") {
-      return Object.entries(parsed).filter(([, value]) => value && typeof value === "object").map(([id, value]) => ({
-        ...value,
-        accountId: value.accountId ?? id
-      }));
-    }
-  } catch {
-    return [];
-  }
-  return [];
-}
-function readRawField(record, keys) {
-  const credentials = record.credentials && typeof record.credentials === "object" ? record.credentials : {};
-  const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
-  const settings = record.settings && typeof record.settings === "object" ? record.settings : {};
-  for (const source of [record, credentials, metadata, settings]) {
-    for (const key of keys) {
-      const value = nonEmptyString(source[key]);
-      if (value)
-        return value;
-    }
-  }
-  return;
-}
-function accountFromRecord(record) {
-  const accountId = normalizeLinearAccountId(record.accountId ?? record.id ?? record.name);
-  const apiKey = readRawField(record, [
-    "LINEAR_API_KEY",
-    "apiKey",
-    "token",
-    "accessToken",
-    "access"
-  ]);
-  if (!apiKey)
-    return null;
-  return {
-    accountId,
-    role: DEFAULT_LINEAR_ACCOUNT_ROLE,
-    apiKey,
-    workspaceId: readRawField(record, ["LINEAR_WORKSPACE_ID", "workspaceId"]),
-    defaultTeamKey: readRawField(record, ["LINEAR_DEFAULT_TEAM_KEY", "defaultTeamKey"]),
-    label: nonEmptyString(record.label ?? record.displayName)
-  };
-}
-function addAccount(accounts, account) {
-  if (account) {
-    accounts.set(account.accountId, account);
-  }
-}
-function readLinearAccounts(runtime) {
-  const accounts = new Map;
-  const characterConfig = runtime.character?.settings?.linear;
-  const characterAccounts = characterConfig?.accounts;
-  if (Array.isArray(characterAccounts)) {
-    for (const item of characterAccounts) {
-      if (item && typeof item === "object") {
-        addAccount(accounts, accountFromRecord(item));
-      }
-    }
-  } else if (characterAccounts && typeof characterAccounts === "object") {
-    for (const [id, value] of Object.entries(characterAccounts)) {
-      if (value && typeof value === "object") {
-        addAccount(accounts, accountFromRecord({
-          ...value,
-          accountId: value.accountId ?? id
-        }));
-      }
-    }
-  }
-  for (const record of parseAccountsJson(readSetting(runtime, "LINEAR_ACCOUNTS"))) {
-    addAccount(accounts, accountFromRecord(record));
-  }
-  const apiKey = readSetting(runtime, "LINEAR_API_KEY");
-  if (apiKey) {
-    addAccount(accounts, {
-      accountId: normalizeLinearAccountId(readSetting(runtime, "LINEAR_ACCOUNT_ID") ?? readSetting(runtime, "LINEAR_DEFAULT_ACCOUNT_ID")),
-      role: DEFAULT_LINEAR_ACCOUNT_ROLE,
-      apiKey,
-      workspaceId: readSetting(runtime, "LINEAR_WORKSPACE_ID"),
-      defaultTeamKey: readSetting(runtime, "LINEAR_DEFAULT_TEAM_KEY")
-    });
-  }
-  return Array.from(accounts.values());
-}
-function resolveLinearAccount(accounts, accountId) {
-  return accounts.find((account) => account.accountId === accountId) ?? null;
-}
-function resolveLinearDefaultAccount(accounts, accountId) {
-  const normalized = normalizeLinearAccountId(accountId);
-  return resolveLinearAccount(accounts, normalized) ?? resolveLinearAccount(accounts, DEFAULT_LINEAR_ACCOUNT_ID) ?? accounts.find((account) => account.role === DEFAULT_LINEAR_ACCOUNT_ROLE) ?? accounts[0] ?? null;
-}
-function hasLinearAccountConfig(runtime, options) {
-  const accountId = resolveLinearAccountId(runtime, options);
-  return Boolean(resolveLinearAccount(readLinearAccounts(runtime), accountId));
-}
-
-// src/actions/account-options.ts
-function getLinearActionOptions(options) {
-  const direct = options ?? {};
-  const parameters = direct.parameters && typeof direct.parameters === "object" ? direct.parameters : {};
-  return { ...direct, ...parameters };
-}
-function getLinearAccountId(runtime, options) {
-  return resolveLinearAccountId(runtime, getLinearActionOptions(options));
-}
-var linearAccountIdParameter = {
-  name: "accountId",
-  description: "Optional Linear account id from LINEAR_ACCOUNTS. Defaults to LINEAR_DEFAULT_ACCOUNT_ID or the legacy single API key.",
-  required: false,
-  schema: { type: "string" }
-};
-
-// src/actions/clearActivity.ts
-import {
-  logger,
-  requireConfirmation
-} from "@elizaos/core";
-
-// src/actions/validate-linear-intent.ts
-async function validateLinearActionIntent(runtime, _message, _state, _spec) {
-  try {
-    return hasLinearAccountConfig(runtime);
-  } catch {
-    return false;
-  }
-}
-
-// src/actions/clearActivity.ts
-var CLEAR_ACTIVITY_TIMEOUT_MS = 1e4;
-var clearActivityAction = {
-  name: "CLEAR_LINEAR_ACTIVITY",
-  contexts: ["tasks", "connectors", "automation"],
-  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
-  roleGate: { minRole: "USER" },
-  description: "Clear the cached Linear activity log for the connected Linear account. Use when the user asks to reset, wipe, or refresh their Linear activity history before pulling a fresh view of recent issue and comment events.",
-  descriptionCompressed: "clear Linear activity log",
-  similes: ["clear-linear-activity", "reset-linear-activity", "delete-linear-activity"],
-  parameters: [linearAccountIdParameter],
-  examples: [
-    [
-      {
-        name: "User",
-        content: {
-          text: "Clear the Linear activity log"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll clear the Linear activity log for you.",
-          actions: ["CLEAR_LINEAR_ACTIVITY"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "Reset Linear activity"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll reset the Linear activity log now.",
-          actions: ["CLEAR_LINEAR_ACTIVITY"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
-    keywords: ["clear", "linear", "activity"],
-    regexAlternation: "clear|linear|activity"
-  }),
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const accountId = getLinearAccountId(runtime, _options);
-      const decision = await requireConfirmation({
-        runtime,
-        message,
-        actionName: "CLEAR_LINEAR_ACTIVITY",
-        pendingKey: `clear_log:${accountId}`,
-        prompt: 'Clear the Linear activity log? Reply "yes" to confirm.',
-        callback
-      });
-      if (decision.status === "pending") {
-        return {
-          text: "Awaiting confirmation to clear Linear activity.",
-          success: true,
-          data: { awaitingUserInput: true }
-        };
-      }
-      if (decision.status === "cancelled") {
-        const cancelMessage = "Clear of Linear activity cancelled.";
-        await callback?.({ text: cancelMessage, source: message.content.source });
-        return {
-          text: cancelMessage,
-          success: true,
-          data: { cancelled: true }
-        };
-      }
-      await Promise.race([
-        linearService.clearActivityLog(accountId),
-        new Promise((_, reject) => setTimeout(() => reject(new Error("Linear clear activity timeout")), CLEAR_ACTIVITY_TIMEOUT_MS))
-      ]);
-      const successMessage = "✅ Linear activity log has been cleared.";
-      await callback?.({
-        text: successMessage,
-        source: message.content.source
-      });
-      return {
-        text: successMessage,
-        success: true
-      };
-    } catch (error) {
-      logger.error("Failed to clear Linear activity:", error);
-      const errorMessage = `❌ Failed to clear Linear activity: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-  }
-};
-
-// src/actions/createComment.ts
-import {
-  logger as logger2,
-  ModelType
-} from "@elizaos/core";
-
-// src/prompts.ts
-var createCommentTemplate = `Extract comment details from the user's request to add a comment to a Linear issue.
-
-User request: "{{userMessage}}"
-
-The user might express this in various ways:
-- "Comment on ENG-123: This looks good"
-- "Tell ENG-123 that the fix is ready for testing"
-- "Add a note to the login bug saying we need more info"
-- "Reply to COM2-7: Thanks for the update"
-- "Let the payment issue know that it's blocked by API changes"
-
-Respond with JSON only. Use this shape:
-{
-  "issueId": "Direct issue ID if explicitly mentioned, for example ENG-123",
-  "issueDescription": "Description or keywords of the issue if no ID was provided",
-  "commentBody": "The actual comment content to add",
-  "commentType": "note|reply|update|question|feedback"
-}
-
-Extract the core message the user wants to convey as the comment body.
-Omit unknown fields. Output only the JSON object, with no prose before or after it.`;
-var createIssueTemplate = `Given the user's request, extract the information needed to create a Linear issue.
-
-User request: "{{userMessage}}"
-
-Respond with JSON only. Use this shape:
-{
-  "title": "Brief, clear issue title",
-  "description": "Detailed description of the issue",
-  "teamKey": "Team key if mentioned, such as ENG or PROD",
-  "priority": 3,
-  "labels": ["label"],
-  "assignee": "Assignee username or email if mentioned"
-}
-
-Omit optional fields when they are not provided. Output only the JSON object, with no prose before or after it.`;
-var deleteIssueTemplate = `Given the user's request to delete/archive a Linear issue, extract the issue identifier.
-
-User request: "{{userMessage}}"
-
-Respond with JSON only:
-{
-  "issueId": "The issue identifier, such as ENG-123 or COM2-7"
-}
-
-Output only the JSON object, with no prose before or after it.`;
-var getActivityTemplate = `Extract activity filter criteria from the user's request.
-
-User request: "{{userMessage}}"
-
-The user might ask for activity in various ways:
-- "Show me today's activity" → time range filter
-- "What issues were created?" → action type filter
-- "What did John do yesterday?" → user filter + time range
-- "Activity on ENG-123" → resource filter
-- "Recent comment activity" → action type + recency
-- "Failed operations this week" → success filter + time range
-
-Respond with JSON only. Use this shape:
-{
-  "timeRange": {
-    "period": "today|yesterday|this-week|last-week|this-month",
-    "from": "ISO datetime if a specific start is mentioned",
-    "to": "ISO datetime if a specific end is mentioned"
-  },
-  "actionTypes": ["create_issue"],
-  "resourceTypes": ["issue"],
-  "resourceId": "Specific resource ID if mentioned, such as ENG-123",
-  "user": "User name, or me for current user",
-  "successFilter": "success|failed|all",
-  "limit": 10
-}
-
-Only include fields that are clearly mentioned. Output only the JSON object, with no prose before or after it.`;
-var getIssueTemplate = `Extract issue identification from the user's request.
-
-User request: "{{userMessage}}"
-
-The user might reference an issue by:
-- Direct ID (e.g., "ENG-123", "COM2-7")
-- Title keywords (e.g., "the login bug", "that payment issue")
-- Assignee (e.g., "John's high priority task")
-- Recency (e.g., "the latest bug", "most recent issue")
-- Team context (e.g., "newest issue in ELIZA team")
-
-Respond with JSON only. Use directId when an issue ID is explicitly mentioned:
-{
-  "directId": "Issue ID such as ENG-123"
-}
-
-When no issue ID is provided, use searchBy fields:
-{
-  "searchBy": {
-    "title": "Keywords from issue title if mentioned",
-    "assignee": "Name or email of assignee if mentioned",
-    "priority": "urgent|high|normal|low|1|2|3|4",
-    "team": "Team name or key if mentioned",
-    "state": "Issue state if mentioned, such as todo, in-progress, or done",
-    "recency": "latest|newest|recent|last",
-    "type": "bug|feature|task"
-  }
-}
-
-Only include fields that are clearly mentioned or implied. Output only the JSON object, with no prose before or after it.`;
-var searchIssuesTemplate = `Extract search criteria from the user's request for Linear issues.
-
-User request: "{{userMessage}}"
-
-The user might express searches in various ways:
-- "Show me what John is working on" → assignee filter
-- "Any blockers for the next release?" → priority/label filters
-- "Issues created this week" → date range filter
-- "My high priority bugs" → assignee (current user) + priority + label
-- "Unassigned tasks in the backend team" → no assignee + team filter
-- "What did Sarah close yesterday?" → assignee + state + date
-- "Bugs that are almost done" → label + state filter
-- "Show me the oldest open issues" → state + sort order
-
-Respond with JSON only. Use this shape:
-{
-  "query": "General search text for title or description",
-  "states": ["In Progress"],
-  "assignees": ["me"],
-  "priorities": ["high"],
-  "teams": ["ENG"],
-  "labels": ["bug"],
-  "hasAssignee": true,
-  "dateRange": {
-    "field": "created|updated|completed",
-    "period": "today|yesterday|this-week|last-week|this-month|last-month",
-    "from": "ISO date if a specific start is mentioned",
-    "to": "ISO date if a specific end is mentioned"
-  },
-  "sort": {
-    "field": "created|updated|priority",
-    "order": "asc|desc"
-  },
-  "limit": 10
-}
-
-Only include fields that are clearly mentioned or implied. For "my" issues, set assignees to ["me"]. Output only the JSON object, with no prose before or after it.`;
-var updateIssueTemplate = `Given the user's request to update a Linear issue, extract the information needed.
-
-User request: "{{userMessage}}"
-
-Respond with JSON only. Use this shape:
-{
-  "issueId": "Issue identifier such as ENG-123 or COM2-7",
-  "updates": {
-    "title": "New title if changing the title",
-    "description": "New description if changing the description",
-    "priority": 3,
-    "teamKey": "New team key if moving to another team, such as ENG, ELIZA, or COM2",
-    "assignee": "New assignee username or email if changing",
-    "status": "todo|in-progress|done|canceled",
-    "labels": ["label"]
-  }
-}
-
-Only include fields that are being updated. Use an empty labels array to clear all labels. Output only the JSON object, with no prose before or after it.`;
-
-// src/actions/parseLinearPrompt.ts
-var EMPTY_SCALAR_VALUES = new Set(["", "none", "null", "undefined", "n/a", "not provided"]);
-var EMPTY_LIST_VALUES = new Set([...EMPTY_SCALAR_VALUES, "clear", "clear all", "no labels"]);
-function isRecord(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function stripWrappingQuotes(value) {
-  const trimmed = value.trim();
-  if (trimmed.startsWith('"') && trimmed.endsWith('"') || trimmed.startsWith("'") && trimmed.endsWith("'")) {
-    return trimmed.slice(1, -1).trim();
-  }
-  return trimmed;
-}
-function normalizeListEntry(value) {
-  return stripWrappingQuotes(value.replace(/^\s*[-*]\s*/, "").trim());
-}
-function splitListString(value) {
-  let trimmed = value.trim();
-  if (trimmed.startsWith("[") && trimmed.endsWith("]")) {
-    trimmed = trimmed.slice(1, -1);
-  }
-  return trimmed.split(/[,\n]/).map(normalizeListEntry).filter(Boolean);
-}
-function parseLinearPromptResponse(response) {
-  try {
-    const trimmed = response.trim();
-    const fenced = trimmed.match(/```(?:json)?\s*([\s\S]*?)\s*```/i);
-    const candidate = (fenced?.[1] ?? trimmed).trim();
-    const firstBrace = candidate.indexOf("{");
-    const lastBrace = candidate.lastIndexOf("}");
-    if (firstBrace < 0 || lastBrace <= firstBrace)
-      return {};
-    const parsed = JSON.parse(candidate.slice(firstBrace, lastBrace + 1));
-    return isRecord(parsed) ? parsed : {};
-  } catch {
-    return {};
-  }
-}
-function getRecordValue(value) {
-  if (isRecord(value)) {
-    return value;
-  }
-  if (typeof value === "string" && value.trim().startsWith("{")) {
-    const parsed = parseLinearPromptResponse(value);
-    return Object.keys(parsed).length > 0 ? parsed : undefined;
-  }
-  return;
-}
-function getStringValue(value) {
-  if (typeof value === "string") {
-    const normalized = stripWrappingQuotes(value);
-    return EMPTY_SCALAR_VALUES.has(normalized.toLowerCase()) ? undefined : normalized;
-  }
-  if (typeof value === "number" || typeof value === "boolean") {
-    return String(value);
-  }
-  return;
-}
-function getStringArrayValue(value) {
-  if (Array.isArray(value)) {
-    return value.flatMap((entry) => {
-      if (entry == null) {
-        return [];
-      }
-      if (typeof entry === "string") {
-        return splitListString(entry);
-      }
-      return [String(entry)];
-    }).filter(Boolean);
-  }
-  if (typeof value === "string") {
-    const normalized = stripWrappingQuotes(value);
-    if (EMPTY_LIST_VALUES.has(normalized.toLowerCase())) {
-      return [];
-    }
-    return splitListString(normalized);
-  }
-  return;
-}
-function getBooleanValue(value) {
-  if (typeof value === "boolean") {
-    return value;
-  }
-  if (typeof value === "string") {
-    const normalized = value.trim().toLowerCase();
-    if (["true", "yes", "y"].includes(normalized)) {
-      return true;
-    }
-    if (["false", "no", "n"].includes(normalized)) {
-      return false;
-    }
-  }
-  return;
-}
-function getNumberValue(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return value;
-  }
-  if (typeof value === "string") {
-    const normalized = value.trim();
-    if (!normalized) {
-      return;
-    }
-    const parsed = Number(normalized);
-    return Number.isFinite(parsed) ? parsed : undefined;
-  }
-  return;
-}
-function getPriorityNumberValue(value) {
-  const numeric = getNumberValue(value);
-  if (numeric) {
-    return numeric;
-  }
-  const priority = getStringValue(value)?.toLowerCase();
-  if (!priority) {
-    return;
-  }
-  const priorityMap = {
-    urgent: 1,
-    high: 2,
-    normal: 3,
-    medium: 3,
-    low: 4
-  };
-  return priorityMap[priority];
-}
-
-// src/actions/createComment.ts
-var createCommentAction = {
-  name: "CREATE_LINEAR_COMMENT",
-  contexts: ["tasks", "connectors", "automation"],
-  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
-  roleGate: { minRole: "USER" },
-  description: "Add a comment to a Linear issue",
-  descriptionCompressed: "add comment Linear issue",
-  parameters: [
-    {
-      name: "issueId",
-      description: "Linear issue id or identifier to comment on.",
-      required: false,
-      schema: { type: "string" }
-    },
-    {
-      name: "body",
-      description: "Comment body to add to the issue.",
-      required: false,
-      schema: { type: "string" }
-    },
-    linearAccountIdParameter
-  ],
-  similes: [
-    "create-linear-comment",
-    "add-linear-comment",
-    "comment-on-linear-issue",
-    "reply-to-linear-issue"
-  ],
-  examples: [
-    [
-      {
-        name: "User",
-        content: {
-          text: "Comment on ENG-123: This looks good to me"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll add your comment to issue ENG-123.",
-          actions: ["CREATE_LINEAR_COMMENT"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "Tell the login bug that we need more information from QA"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll add that comment to the login bug issue.",
-          actions: ["CREATE_LINEAR_COMMENT"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "Reply to COM2-7: Thanks for the update, I'll look into it"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll add your reply to issue COM2-7.",
-          actions: ["CREATE_LINEAR_COMMENT"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
-    keywords: ["create", "linear", "comment"],
-    regexAlternation: "create|linear|comment"
-  }),
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const accountId = getLinearAccountId(runtime, _options);
-      const content = message.content.text;
-      if (!content) {
-        const errorMessage = "Please provide a message with the issue and comment content.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      let issueId;
-      let commentBody;
-      const params = _options?.parameters;
-      if (params?.issueId && params?.body) {
-        issueId = params.issueId;
-        commentBody = params.body;
-      } else {
-        const prompt = createCommentTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType.TEXT_LARGE, {
-          prompt
-        });
-        if (!response) {
-          const issueMatch = content.match(/(?:comment on|add.*comment.*to|reply to|tell)\s+(\w+-\d+):?\s*(.*)/i);
-          if (issueMatch) {
-            issueId = issueMatch[1];
-            commentBody = issueMatch[2].trim();
-          } else {
-            throw new Error("Could not understand comment request");
-          }
-        } else {
-          try {
-            const parsed = parseLinearPromptResponse(response);
-            if (Object.keys(parsed).length === 0) {
-              throw new Error("No fields found in model response");
-            }
-            const parsedIssueId = getStringValue(parsed.issueId);
-            const issueDescription = getStringValue(parsed.issueDescription);
-            const parsedCommentBody = getStringValue(parsed.commentBody) ?? "";
-            if (parsedIssueId) {
-              issueId = parsedIssueId;
-              commentBody = parsedCommentBody;
-            } else if (issueDescription) {
-              const filters = {
-                query: issueDescription,
-                limit: 5
-              };
-              const defaultTeamKey = linearService.getDefaultTeamKey(accountId) ?? runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-              if (defaultTeamKey) {
-                filters.team = defaultTeamKey;
-              }
-              const issues = await linearService.searchIssues(filters, accountId);
-              if (issues.length === 0) {
-                const errorMessage = `No issues found matching "${issueDescription}". Please provide a specific issue ID.`;
-                await callback?.({
-                  text: errorMessage,
-                  source: message.content.source
-                });
-                return {
-                  text: errorMessage,
-                  success: false
-                };
-              }
-              if (issues.length === 1) {
-                issueId = issues[0].identifier;
-                commentBody = parsedCommentBody;
-              } else {
-                const issueList = await Promise.all(issues.map(async (issue2, index) => {
-                  const state = await issue2.state;
-                  return `${index + 1}. ${issue2.identifier}: ${issue2.title} (${state?.name || "No state"})`;
-                }));
-                const clarifyMessage = `Found multiple issues matching "${issueDescription}":
-${issueList.join(`
-`)}
-
-Please specify which issue to comment on by its ID.`;
-                await callback?.({
-                  text: clarifyMessage,
-                  source: message.content.source
-                });
-                return {
-                  text: clarifyMessage,
-                  success: false,
-                  data: {
-                    multipleMatches: true,
-                    issues: issues.map((i) => ({
-                      id: i.id,
-                      identifier: i.identifier,
-                      title: i.title
-                    })),
-                    pendingComment: parsedCommentBody
-                  }
-                };
-              }
-            } else {
-              throw new Error("No issue identifier or description found");
-            }
-            const commentType = getStringValue(parsed.commentType)?.toLowerCase();
-            if (commentType && commentType !== "note") {
-              commentBody = `[${commentType.toUpperCase()}] ${commentBody}`;
-            }
-          } catch (parseError) {
-            logger2.warn("Failed to parse LLM response, falling back to regex:", parseError);
-            const issueMatch = content.match(/(?:comment on|add.*comment.*to|reply to|tell)\s+(\w+-\d+):?\s*(.*)/i);
-            if (!issueMatch) {
-              const errorMessage = 'Please specify the issue ID and comment content. Example: "Comment on ENG-123: This looks good"';
-              await callback?.({
-                text: errorMessage,
-                source: message.content.source
-              });
-              return {
-                text: errorMessage,
-                success: false
-              };
-            }
-            issueId = issueMatch[1];
-            commentBody = issueMatch[2].trim();
-          }
-        }
-      }
-      if (!commentBody || commentBody.length === 0) {
-        const errorMessage = "Please provide the comment content.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      const issue = await linearService.getIssue(issueId, accountId);
-      const comment = await linearService.createComment({
-        issueId: issue.id,
-        body: commentBody
-      }, accountId);
-      const successMessage = `✅ Comment added to issue ${issue.identifier}: "${commentBody}"`;
-      await callback?.({
-        text: successMessage,
-        source: message.content.source
-      });
-      return {
-        text: `Added comment to issue ${issue.identifier}`,
-        success: true,
-        data: {
-          commentId: comment.id,
-          issueId: issue.id,
-          issueIdentifier: issue.identifier,
-          commentBody,
-          createdAt: comment.createdAt instanceof Date ? comment.createdAt.toISOString() : comment.createdAt,
-          accountId
-        }
-      };
-    } catch (error) {
-      logger2.error("Failed to create comment:", error);
-      const errorMessage = `❌ Failed to create comment: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-  }
-};
-
-// src/actions/createIssue.ts
-import {
-  logger as logger3,
-  ModelType as ModelType2
-} from "@elizaos/core";
-var createIssueAction = {
-  name: "CREATE_LINEAR_ISSUE",
-  contexts: ["tasks", "connectors", "automation"],
-  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
-  roleGate: { minRole: "USER" },
-  description: "Create a new Linear issue with title, description, priority, team, assignee, and labels. Use when the user wants to file, log, or track a new ticket, bug, story, or task in Linear from chat.",
-  descriptionCompressed: "create new issue Linear",
-  parameters: [
-    {
-      name: "issueData",
-      description: "Structured Linear issue fields.",
-      required: false,
-      schema: {
-        type: "object",
-        properties: {
-          title: { type: "string" },
-          description: { type: "string" },
-          priority: { type: "number" },
-          teamId: { type: "string" },
-          assigneeId: { type: "string" },
-          labelIds: { type: "array", items: { type: "string" } }
-        }
-      }
-    },
-    linearAccountIdParameter
-  ],
-  similes: ["create-linear-issue", "new-linear-issue", "add-linear-issue"],
-  examples: [
-    [
-      {
-        name: "User",
-        content: {
-          text: "Create a new issue: Fix login button not working on mobile devices"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll create that issue for you in Linear.",
-          actions: ["CREATE_LINEAR_ISSUE"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "Create a bug report for the ENG team: API returns 500 error when updating user profile"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll create a bug report for the engineering team right away.",
-          actions: ["CREATE_LINEAR_ISSUE"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
-    keywords: ["create", "linear", "issue"],
-    regexAlternation: "create|linear|issue"
-  }),
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const accountId = getLinearAccountId(runtime, _options);
-      const content = message.content.text;
-      if (!content) {
-        const errorMessage = "Please provide a description for the issue.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      const params = _options?.parameters;
-      const structuredData = params?.issueData;
-      let issueData;
-      if (structuredData) {
-        issueData = structuredData;
-      } else {
-        const prompt = createIssueTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType2.TEXT_LARGE, {
-          prompt
-        });
-        if (!response) {
-          throw new Error("Failed to extract issue information");
-        }
-        try {
-          const parsed = parseLinearPromptResponse(response);
-          if (Object.keys(parsed).length === 0) {
-            throw new Error("No fields found in model response");
-          }
-          issueData = {
-            title: getStringValue(parsed.title),
-            description: getStringValue(parsed.description),
-            priority: getPriorityNumberValue(parsed.priority)
-          };
-          const teamKey = getStringValue(parsed.teamKey);
-          if (teamKey) {
-            const teams = await linearService.getTeams(accountId);
-            const team = teams.find((t) => t.key.toLowerCase() === teamKey.toLowerCase());
-            if (team) {
-              issueData.teamId = team.id;
-            }
-          }
-          const assignee = getStringValue(parsed.assignee);
-          if (assignee) {
-            const cleanAssignee = assignee.replace(/^@/, "");
-            const users = await linearService.getUsers(accountId);
-            const user = users.find((u) => u.email === cleanAssignee || u.name.toLowerCase().includes(cleanAssignee.toLowerCase()));
-            if (user) {
-              issueData.assigneeId = user.id;
-            }
-          }
-          const parsedLabels = getStringArrayValue(parsed.labels);
-          if (parsedLabels && parsedLabels.length > 0) {
-            const labels = await linearService.getLabels(issueData.teamId, accountId);
-            const labelIds = [];
-            for (const labelName of parsedLabels) {
-              const label = labels.find((l) => l.name.toLowerCase() === labelName.toLowerCase());
-              if (label) {
-                labelIds.push(label.id);
-              }
-            }
-            if (labelIds.length > 0) {
-              issueData.labelIds = labelIds;
-            }
-          }
-          if (!issueData.teamId) {
-            const defaultTeamKey = linearService.getDefaultTeamKey(accountId) ?? runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-            if (defaultTeamKey) {
-              const teams = await linearService.getTeams(accountId);
-              const defaultTeam = teams.find((t) => t.key.toLowerCase() === defaultTeamKey.toLowerCase());
-              if (defaultTeam) {
-                issueData.teamId = defaultTeam.id;
-                logger3.info(`Using configured default team: ${defaultTeam.name} (${defaultTeam.key})`);
-              } else {
-                logger3.warn(`Default team key ${defaultTeamKey} not found`);
-              }
-            }
-            if (!issueData.teamId) {
-              const teams = await linearService.getTeams(accountId);
-              if (teams.length > 0) {
-                issueData.teamId = teams[0].id;
-                logger3.warn(`No team specified, using first available team: ${teams[0].name}`);
-              }
-            }
-          }
-        } catch (parseError) {
-          logger3.error("Failed to parse LLM response:", parseError);
-          issueData = {
-            title: content.length > 100 ? `${content.substring(0, 100)}...` : content,
-            description: content
-          };
-          const defaultTeamKey = linearService.getDefaultTeamKey(accountId) ?? runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-          const teams = await linearService.getTeams(accountId);
-          if (defaultTeamKey) {
-            const defaultTeam = teams.find((t) => t.key.toLowerCase() === defaultTeamKey.toLowerCase());
-            if (defaultTeam) {
-              issueData.teamId = defaultTeam.id;
-              logger3.info(`Using configured default team for fallback: ${defaultTeam.name} (${defaultTeam.key})`);
-            }
-          }
-          if (!issueData.teamId && teams.length > 0) {
-            issueData.teamId = teams[0].id;
-            logger3.warn(`Using first available team for fallback: ${teams[0].name}`);
-          }
-        }
-      }
-      if (!issueData.title) {
-        const errorMessage = "Could not determine issue title. Please provide more details.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      if (!issueData.teamId) {
-        const errorMessage = "No Linear teams found. Please ensure at least one team exists in your Linear workspace.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      const issue = await linearService.createIssue(issueData, accountId);
-      const successMessage = `✅ Created Linear issue: ${issue.title} (${issue.identifier})
-
-View it at: ${issue.url}`;
-      await callback?.({
-        text: successMessage,
-        source: message.content.source
-      });
-      return {
-        text: `Created issue: ${issue.title} (${issue.identifier})`,
-        success: true,
-        data: {
-          issueId: issue.id,
-          identifier: issue.identifier,
-          url: issue.url,
-          accountId
-        }
-      };
-    } catch (error) {
-      logger3.error("Failed to create issue:", error);
-      const errorMessage = `❌ Failed to create issue: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-  }
-};
-
-// src/actions/deleteComment.ts
-import {
-  logger as logger4
-} from "@elizaos/core";
-var deleteCommentAction = {
-  name: "DELETE_LINEAR_COMMENT",
-  contexts: ["tasks", "connectors", "automation"],
-  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
-  roleGate: { minRole: "USER" },
-  description: "Delete a specific Linear comment by its comment id. Use when the user asks to remove, retract, or erase a comment they previously left on a Linear issue.",
-  descriptionCompressed: "delete Linear comment id",
-  parameters: [
-    {
-      name: "commentId",
-      description: "Linear comment id to delete.",
-      required: false,
-      schema: { type: "string" }
-    },
-    linearAccountIdParameter
-  ],
-  similes: ["remove-linear-comment", "erase-linear-comment"],
-  examples: [
-    [
-      {
-        name: "User",
-        content: { text: "Delete comment abc-123 from ENG-456." }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll delete that comment.",
-          actions: ["DELETE_LINEAR_COMMENT"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
-    keywords: ["delete", "remove", "linear", "comment"],
-    regexAlternation: "delete|remove|linear|comment"
-  }),
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const accountId = getLinearAccountId(runtime, _options);
-      const params = _options?.parameters;
-      const commentId = params?.commentId?.trim() ?? "";
-      if (!commentId) {
-        const errorMessage = "Please provide a commentId to delete.";
-        await callback?.({ text: errorMessage, source: message.content.source });
-        return { text: errorMessage, success: false };
-      }
-      await linearService.deleteComment(commentId, accountId);
-      const successMessage = `Deleted comment ${commentId}.`;
-      await callback?.({ text: successMessage, source: message.content.source });
-      return {
-        text: successMessage,
-        success: true,
-        data: { commentId, accountId }
-      };
-    } catch (error) {
-      logger4.error("Failed to delete comment:", error);
-      const errorMessage = `Failed to delete comment: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({ text: errorMessage, source: message.content.source });
-      return { text: errorMessage, success: false };
-    }
-  }
-};
-
-// src/actions/deleteIssue.ts
-import {
-  logger as logger5,
-  ModelType as ModelType3,
-  requireConfirmation as requireConfirmation2
-} from "@elizaos/core";
-var LINEAR_MODEL_TIMEOUT_MS = 15000;
-var LINEAR_ISSUE_TITLE_MAX_CHARS = 300;
-var deleteIssueAction = {
-  name: "DELETE_LINEAR_ISSUE",
-  contexts: ["tasks", "connectors", "automation"],
-  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
-  roleGate: { minRole: "USER" },
-  description: "Delete (archive) an issue in Linear",
-  descriptionCompressed: "delete (archive) issue Linear",
-  parameters: [
-    {
-      name: "issueId",
-      description: "Linear issue id or identifier to archive.",
-      required: false,
-      schema: { type: "string" }
-    },
-    linearAccountIdParameter
-  ],
-  similes: [
-    "delete-linear-issue",
-    "archive-linear-issue",
-    "remove-linear-issue",
-    "close-linear-issue"
-  ],
-  examples: [
-    [
-      {
-        name: "User",
-        content: {
-          text: "Delete issue ENG-123"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll archive issue ENG-123 for you.",
-          actions: ["DELETE_LINEAR_ISSUE"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "Remove COM2-7 from Linear"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll archive issue COM2-7 in Linear.",
-          actions: ["DELETE_LINEAR_ISSUE"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "Archive the bug report BUG-456"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll archive issue BUG-456 for you.",
-          actions: ["DELETE_LINEAR_ISSUE"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
-    keywords: ["delete", "linear", "issue"],
-    regexAlternation: "delete|linear|issue"
-  }),
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const accountId = getLinearAccountId(runtime, _options);
-      const content = message.content.text;
-      if (!content) {
-        const errorMessage = "Please specify which issue to delete.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      let issueId;
-      const params = _options?.parameters;
-      if (params?.issueId) {
-        issueId = params.issueId;
-      } else {
-        const prompt = deleteIssueTemplate.replace("{{userMessage}}", content);
-        const response = await Promise.race([
-          runtime.useModel(ModelType3.TEXT_LARGE, {
-            prompt
-          }),
-          new Promise((_, reject) => setTimeout(() => reject(new Error("Linear issue extraction timeout")), LINEAR_MODEL_TIMEOUT_MS))
-        ]);
-        if (!response) {
-          throw new Error("Failed to extract issue identifier");
-        }
-        try {
-          const parsed = parseLinearPromptResponse(response);
-          if (Object.keys(parsed).length === 0) {
-            throw new Error("No fields found in model response");
-          }
-          issueId = getStringValue(parsed.issueId) ?? "";
-          if (!issueId) {
-            throw new Error("Issue ID not found in parsed response");
-          }
-        } catch (parseError) {
-          logger5.warn("Failed to parse LLM response, falling back to regex parsing:", parseError);
-          const issueMatch = content.match(/(\w+-\d+)/);
-          if (!issueMatch) {
-            const errorMessage = "Please specify an issue ID (e.g., ENG-123) to delete.";
-            await callback?.({
-              text: errorMessage,
-              source: message.content.source
-            });
-            return {
-              text: errorMessage,
-              success: false
-            };
-          }
-          issueId = issueMatch[1];
-        }
-      }
-      const issue = await linearService.getIssue(issueId, accountId);
-      const issueTitle = issue.title.slice(0, LINEAR_ISSUE_TITLE_MAX_CHARS);
-      const issueIdentifier = issue.identifier;
-      const decision = await requireConfirmation2({
-        runtime,
-        message,
-        actionName: "DELETE_LINEAR_ISSUE",
-        pendingKey: `archive:${issue.id}`,
-        prompt: `Archive issue ${issueIdentifier}: "${issueTitle}"? This moves it out of active views. Reply "yes" to confirm.`,
-        callback
-      });
-      if (decision.status === "pending") {
-        return {
-          text: `Awaiting confirmation to archive ${issueIdentifier}.`,
-          success: true,
-          data: { awaitingUserInput: true, issueId: issue.id, identifier: issueIdentifier }
-        };
-      }
-      if (decision.status === "cancelled") {
-        const cancelMessage = `Archive of ${issueIdentifier} cancelled.`;
-        await callback?.({ text: cancelMessage, source: message.content.source });
-        return {
-          text: cancelMessage,
-          success: true,
-          data: { cancelled: true, issueId: issue.id, identifier: issueIdentifier }
-        };
-      }
-      logger5.info(`Archiving issue ${issueIdentifier}: ${issueTitle}`);
-      await linearService.deleteIssue(issueId, accountId);
-      const successMessage = `✅ Successfully archived issue ${issueIdentifier}: "${issueTitle}"
-
-The issue has been moved to the archived state and will no longer appear in active views.`;
-      await callback?.({
-        text: successMessage,
-        source: message.content.source
-      });
-      return {
-        text: `Archived issue ${issueIdentifier}: "${issueTitle}"`,
-        success: true,
-        data: {
-          issueId: issue.id,
-          identifier: issueIdentifier,
-          title: issueTitle,
-          archived: true,
-          accountId
-        }
-      };
-    } catch (error) {
-      logger5.error("Failed to delete issue:", error);
-      const errorMessage = `❌ Failed to delete issue: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-  }
-};
-
-// src/actions/getActivity.ts
-import {
-  logger as logger6,
-  ModelType as ModelType4
-} from "@elizaos/core";
-function formatActivityDetail(value) {
-  if (value === null || value === undefined) {
-    return "none";
-  }
-  if (Array.isArray(value)) {
-    return value.map(formatActivityDetail).join(", ");
-  }
-  if (typeof value === "object") {
-    return Object.entries(value).map(([key, nestedValue]) => `${key}=${formatActivityDetail(nestedValue)}`).join("; ");
-  }
-  return String(value);
-}
-var getActivityAction = {
-  name: "GET_LINEAR_ACTIVITY",
-  contexts: ["tasks", "connectors", "automation"],
-  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
-  roleGate: { minRole: "USER" },
-  description: "Get recent Linear activity log with optional filters",
-  descriptionCompressed: "get recent Linear activity log w/ optional filter",
-  similes: [
-    "get-linear-activity",
-    "show-linear-activity",
-    "view-linear-activity",
-    "check-linear-activity"
-  ],
-  parameters: [
-    {
-      name: "filters",
-      description: "Optional activity filters, e.g. fromDate ISO timestamp, action, resource_type, resource_id, or success.",
-      required: false,
-      schema: { type: "object" }
-    },
-    {
-      name: "limit",
-      description: "Maximum number of activity log entries to return.",
-      required: false,
-      schema: { type: "number" }
-    },
-    linearAccountIdParameter
-  ],
-  examples: [
-    [
-      {
-        name: "User",
-        content: {
-          text: "Show me recent Linear activity"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll show you the recent Linear activity.",
-          actions: ["GET_LINEAR_ACTIVITY"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "What happened in Linear today?"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "Let me check today's Linear activity for you.",
-          actions: ["GET_LINEAR_ACTIVITY"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "Show me what issues John created this week"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll find the issues John created this week.",
-          actions: ["GET_LINEAR_ACTIVITY"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
-    keywords: ["get", "linear", "activity"],
-    regexAlternation: "get|linear|activity"
-  }),
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const accountId = getLinearAccountId(runtime, _options);
-      const content = message.content.text || "";
-      const params = _options?.parameters ?? {};
-      const filters = { ...params.filters ?? {} };
-      let limit = typeof params.limit === "number" && Number.isFinite(params.limit) ? Math.max(1, Math.floor(params.limit)) : 10;
-      if (content) {
-        const prompt = getActivityTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType4.TEXT_LARGE, {
-          prompt
-        });
-        if (response) {
-          try {
-            const parsed = parseLinearPromptResponse(response);
-            if (Object.keys(parsed).length === 0) {
-              throw new Error("No fields found in model response");
-            }
-            const timeRange = getRecordValue(parsed.timeRange);
-            if (timeRange) {
-              const now = new Date;
-              let fromDate;
-              const from = getStringValue(timeRange.from);
-              const period = getStringValue(timeRange.period);
-              if (from) {
-                fromDate = new Date(from);
-              } else if (period) {
-                switch (period) {
-                  case "today":
-                    fromDate = new Date(now.setHours(0, 0, 0, 0));
-                    break;
-                  case "yesterday":
-                    fromDate = new Date(now.setDate(now.getDate() - 1));
-                    fromDate.setHours(0, 0, 0, 0);
-                    break;
-                  case "this-week":
-                    fromDate = new Date(now.setDate(now.getDate() - now.getDay()));
-                    fromDate.setHours(0, 0, 0, 0);
-                    break;
-                  case "last-week":
-                    fromDate = new Date(now.setDate(now.getDate() - now.getDay() - 7));
-                    fromDate.setHours(0, 0, 0, 0);
-                    break;
-                  case "this-month":
-                    fromDate = new Date(now.getFullYear(), now.getMonth(), 1);
-                    break;
-                }
-              }
-              if (fromDate) {
-                filters.fromDate = fromDate.toISOString();
-              }
-            }
-            const actionTypes = getStringArrayValue(parsed.actionTypes);
-            if (actionTypes && actionTypes.length > 0) {
-              filters.action = actionTypes[0];
-            }
-            const resourceTypes = getStringArrayValue(parsed.resourceTypes);
-            if (resourceTypes && resourceTypes.length > 0) {
-              filters.resource_type = resourceTypes[0];
-            }
-            const resourceId = getStringValue(parsed.resourceId);
-            if (resourceId) {
-              filters.resource_id = resourceId;
-            }
-            const successFilter = getStringValue(parsed.successFilter);
-            if (successFilter && successFilter !== "all") {
-              filters.success = successFilter === "success";
-            }
-            limit = getNumberValue(parsed.limit) || 10;
-          } catch (parseError) {
-            logger6.warn("Failed to parse activity filters:", parseError);
-          }
-        }
-      }
-      let activity = linearService.getActivityLog(limit * 2, filters, accountId);
-      if (filters.fromDate) {
-        const fromDateValue = filters.fromDate;
-        const fromDate = typeof fromDateValue === "string" ? fromDateValue : fromDateValue instanceof Date ? fromDateValue.toISOString() : String(fromDateValue);
-        const fromTime = new Date(fromDate).getTime();
-        if (!Number.isNaN(fromTime)) {
-          activity = activity.filter((item) => new Date(item.timestamp).getTime() >= fromTime);
-        }
-      }
-      activity = activity.slice(0, limit);
-      if (activity.length === 0) {
-        const noActivityMessage = filters.fromDate ? `No Linear activity found for the specified filters.` : "No recent Linear activity found.";
-        await callback?.({
-          text: noActivityMessage,
-          source: message.content.source
-        });
-        return {
-          text: noActivityMessage,
-          success: true,
-          data: {
-            activity: [],
-            accountId
-          }
-        };
-      }
-      const activityText = activity.map((item, index) => {
-        const time = new Date(item.timestamp).toLocaleString();
-        const status = item.success ? "✅" : "❌";
-        const details = Object.entries(item.details).filter(([key]) => key !== "filters").map(([key, value]) => `${key}: ${formatActivityDetail(value)}`).join(", ");
-        return `${index + 1}. ${status} ${item.action} on ${item.resource_type} ${item.resource_id}
-   Time: ${time}
-   ${details ? `Details: ${details}` : ""}${item.error ? `
-   Error: ${item.error}` : ""}`;
-      }).join(`
-
-`);
-      const headerText = filters.fromDate ? `\uD83D\uDCCA Linear activity ${content}:` : "\uD83D\uDCCA Recent Linear activity:";
-      const resultMessage = `${headerText}
-
-${activityText}`;
-      await callback?.({
-        text: resultMessage,
-        source: message.content.source
-      });
-      return {
-        text: `Found ${activity.length} activity item${activity.length === 1 ? "" : "s"}`,
-        success: true,
-        data: {
-          activity: activity.map((item) => ({
-            id: item.id,
-            action: item.action,
-            resource_type: item.resource_type,
-            resource_id: item.resource_id,
-            success: item.success,
-            error: item.error,
-            details: formatActivityDetail(item.details),
-            timestamp: typeof item.timestamp === "string" ? item.timestamp : new Date(item.timestamp).toISOString()
-          })),
-          filters: filters ? {
-            ...filters,
-            fromDate: filters.fromDate ? typeof filters.fromDate === "string" ? filters.fromDate : String(filters.fromDate) : undefined
-          } : undefined,
-          count: activity.length,
-          accountId
-        }
-      };
-    } catch (error) {
-      logger6.error("Failed to get activity:", error);
-      const errorMessage = `❌ Failed to get activity: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-  }
-};
-
-// src/actions/getIssue.ts
-import {
-  logger as logger7,
-  ModelType as ModelType5
-} from "@elizaos/core";
-var getIssueAction = {
-  name: "GET_LINEAR_ISSUE",
-  contexts: ["tasks", "connectors", "knowledge"],
-  contextGate: { anyOf: ["tasks", "connectors", "knowledge"] },
-  roleGate: { minRole: "USER" },
-  description: "Get details of a specific Linear issue",
-  descriptionCompressed: "get detail specific Linear issue",
-  similes: [
-    "get-linear-issue",
-    "show-linear-issue",
-    "view-linear-issue",
-    "check-linear-issue",
-    "find-linear-issue"
-  ],
-  parameters: [
-    {
-      name: "issueId",
-      description: "Linear issue identifier or id, e.g. ENG-123.",
-      required: false,
-      schema: { type: "string" }
-    },
-    {
-      name: "query",
-      description: "Search text when the exact Linear issue identifier is unknown.",
-      required: false,
-      schema: { type: "string" }
-    },
-    linearAccountIdParameter
-  ],
-  examples: [
-    [
-      {
-        name: "User",
-        content: {
-          text: "Show me issue ENG-123"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll get the details for issue ENG-123.",
-          actions: ["GET_LINEAR_ISSUE"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "What's the status of the login bug?"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "Let me find the login bug issue for you.",
-          actions: ["GET_LINEAR_ISSUE"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "Show me the latest high priority issue assigned to Sarah"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll find the latest high priority issue assigned to Sarah.",
-          actions: ["GET_LINEAR_ISSUE"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
-    keywords: ["get", "linear", "issue"],
-    regexAlternation: "get|linear|issue"
-  }),
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const accountId = getLinearAccountId(runtime, _options);
-      const params = _options?.parameters ?? {};
-      const content = params.query ?? params.issueId ?? message.content.text;
-      if (!content) {
-        const errorMessage2 = "Please specify which issue you want to see.";
-        await callback?.({
-          text: errorMessage2,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage2,
-          success: false
-        };
-      }
-      if (params.issueId) {
-        const issue = await linearService.getIssue(params.issueId, accountId);
-        return await formatIssueResponse(issue, callback, message);
-      }
-      const prompt = getIssueTemplate.replace("{{userMessage}}", content);
-      const response = await runtime.useModel(ModelType5.TEXT_LARGE, {
-        prompt
-      });
-      if (!response) {
-        const issueMatch = content.match(/(\w+-\d+)/);
-        if (issueMatch) {
-          const issue = await linearService.getIssue(issueMatch[1], accountId);
-          return await formatIssueResponse(issue, callback, message);
-        }
-        throw new Error("Could not understand issue reference");
-      }
-      try {
-        const parsed = parseLinearPromptResponse(response);
-        if (Object.keys(parsed).length === 0) {
-          throw new Error("No fields found in model response");
-        }
-        const directId = getStringValue(parsed.directId);
-        if (directId) {
-          const issue = await linearService.getIssue(directId, accountId);
-          return await formatIssueResponse(issue, callback, message);
-        }
-        const searchBy = getRecordValue(parsed.searchBy);
-        if (searchBy && Object.keys(searchBy).length > 0) {
-          const filters = {};
-          const title = getStringValue(searchBy.title);
-          if (title) {
-            filters.query = title;
-          }
-          const assignee = getStringValue(searchBy.assignee);
-          if (assignee) {
-            filters.assignee = [assignee];
-          }
-          const priorityValue = getStringValue(searchBy.priority);
-          if (priorityValue) {
-            const priorityMap = {
-              urgent: 1,
-              high: 2,
-              normal: 3,
-              low: 4,
-              "1": 1,
-              "2": 2,
-              "3": 3,
-              "4": 4
-            };
-            const priority = priorityMap[priorityValue.toLowerCase()];
-            if (priority) {
-              filters.priority = [priority];
-            }
-          }
-          const team = getStringValue(searchBy.team);
-          if (team) {
-            filters.team = team;
-          }
-          const state = getStringValue(searchBy.state);
-          if (state) {
-            filters.state = [state];
-          }
-          const defaultTeamKey = linearService.getDefaultTeamKey(accountId) ?? runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-          if (defaultTeamKey && !filters.team) {
-            filters.team = defaultTeamKey;
-          }
-          const issues = await linearService.searchIssues({
-            ...filters,
-            limit: getStringValue(searchBy.recency) ? 10 : 5
-          }, accountId);
-          if (issues.length === 0) {
-            const noResultsMessage = "No issues found matching your criteria.";
-            await callback?.({
-              text: noResultsMessage,
-              source: message.content.source
-            });
-            return {
-              text: noResultsMessage,
-              success: false
-            };
-          }
-          if (getStringValue(searchBy.recency)) {
-            issues.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime());
-          }
-          if (getStringValue(searchBy.recency) && issues.length > 0) {
-            return await formatIssueResponse(issues[0], callback, message);
-          }
-          if (issues.length === 1) {
-            return await formatIssueResponse(issues[0], callback, message);
-          }
-          const issueList = await Promise.all(issues.slice(0, 5).map(async (issue, index) => {
-            const state2 = await issue.state;
-            return `${index + 1}. ${issue.identifier}: ${issue.title} (${state2?.name || "No state"})`;
-          }));
-          const clarifyMessage = `Found ${issues.length} issues matching your criteria:
-${issueList.join(`
-`)}
-
-Please specify which one you want to see by its ID.`;
-          await callback?.({
-            text: clarifyMessage,
-            source: message.content.source
-          });
-          return {
-            text: clarifyMessage,
-            success: true,
-            data: {
-              multipleResults: true,
-              issues: issues.slice(0, 5).map((i) => ({
-                id: i.id,
-                identifier: i.identifier,
-                title: i.title
-              }))
-            }
-          };
-        }
-      } catch (parseError) {
-        logger7.warn("Failed to parse LLM response, falling back to regex:", parseError);
-        const issueMatch = content.match(/(\w+-\d+)/);
-        if (issueMatch) {
-          const issue = await linearService.getIssue(issueMatch[1], accountId);
-          return await formatIssueResponse(issue, callback, message);
-        }
-      }
-      const errorMessage = "Could not understand which issue you want to see. Please provide an issue ID (e.g., ENG-123) or describe it more specifically.";
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    } catch (error) {
-      logger7.error("Failed to get issue:", error);
-      const errorMessage = `❌ Failed to get issue: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-  }
-};
-async function formatIssueResponse(issue, callback, message) {
-  const assignee = await issue.assignee;
-  const state = await issue.state;
-  const team = await issue.team;
-  const labels = await issue.labels();
-  const project = await issue.project;
-  const issueDetails = {
-    id: issue.id,
-    identifier: issue.identifier,
-    title: issue.title,
-    description: issue.description,
-    priority: issue.priority,
-    priorityLabel: issue.priorityLabel,
-    url: issue.url,
-    createdAt: issue.createdAt,
-    updatedAt: issue.updatedAt,
-    dueDate: issue.dueDate,
-    estimate: issue.estimate,
-    assignee: assignee ? {
-      id: assignee.id,
-      name: assignee.name,
-      email: assignee.email
-    } : null,
-    state: state ? {
-      id: state.id,
-      name: state.name,
-      type: state.type,
-      color: state.color
-    } : null,
-    team: team ? {
-      id: team.id,
-      name: team.name,
-      key: team.key
-    } : null,
-    labels: labels.nodes.map((label) => ({
-      id: label.id,
-      name: label.name,
-      color: label.color
-    })),
-    project: project ? {
-      id: project.id,
-      name: project.name,
-      description: project.description
-    } : null
-  };
-  const priorityLabels = ["", "Urgent", "High", "Normal", "Low"];
-  const priority = priorityLabels[issue.priority || 0] || "No priority";
-  const labelText = issueDetails.labels.length > 0 ? `Labels: ${issueDetails.labels.map((l) => l.name).join(", ")}` : "";
-  const issueMessage = `\uD83D\uDCCB **${issue.identifier}: ${issue.title}**
-  
-Status: ${state?.name || "No status"}
-Priority: ${priority}
-Team: ${team?.name || "No team"}
-Assignee: ${assignee?.name || "Unassigned"}
-${issue.dueDate ? `Due: ${new Date(issue.dueDate).toLocaleDateString()}` : ""}
-${labelText}
-${project ? `Project: ${project.name}` : ""}
-
-${issue.description || "No description"}
-
-View in Linear: ${issue.url}`;
-  await callback?.({
-    text: issueMessage,
-    source: message.content.source
-  });
-  const serializedIssue = {
-    ...issueDetails,
-    createdAt: issueDetails.createdAt instanceof Date ? issueDetails.createdAt.toISOString() : issueDetails.createdAt,
-    updatedAt: issueDetails.updatedAt instanceof Date ? issueDetails.updatedAt.toISOString() : issueDetails.updatedAt,
-    dueDate: issueDetails.dueDate ? issueDetails.dueDate instanceof Date ? issueDetails.dueDate.toISOString() : issueDetails.dueDate : null
-  };
-  return {
-    text: `Retrieved issue ${issue.identifier}: ${issue.title}`,
-    success: true,
-    data: { issue: serializedIssue }
-  };
-}
-
-// src/actions/listComments.ts
-import {
-  logger as logger8
-} from "@elizaos/core";
-var listCommentsAction = {
-  name: "LIST_LINEAR_COMMENTS",
-  contexts: ["tasks", "connectors", "automation"],
-  contextGate: { anyOf: ["tasks", "connectors", "automation"] },
-  roleGate: { minRole: "USER" },
-  description: "List comments on a Linear issue",
-  descriptionCompressed: "list comment Linear issue",
-  parameters: [
-    {
-      name: "issueId",
-      description: "Linear issue id or identifier to list comments for.",
-      required: false,
-      schema: { type: "string" }
-    },
-    {
-      name: "limit",
-      description: "Maximum number of comments to return (default 25, max 100).",
-      required: false,
-      schema: { type: "number" }
-    },
-    linearAccountIdParameter
-  ],
-  similes: ["get-linear-comments", "show-linear-comments", "fetch-linear-comments"],
-  examples: [
-    [
-      {
-        name: "User",
-        content: { text: "Show the comments on ENG-123." }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "Here are the comments on ENG-123.",
-          actions: ["LIST_LINEAR_COMMENTS"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
-    keywords: ["list", "comments", "linear", "issue"],
-    regexAlternation: "list|comments|linear|issue"
-  }),
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const accountId = getLinearAccountId(runtime, _options);
-      const params = _options?.parameters;
-      const issueId = params?.issueId?.trim() ?? "";
-      const limit = typeof params?.limit === "number" ? Math.min(Math.max(1, params.limit), 100) : 25;
-      if (!issueId) {
-        const match = message.content.text?.match(/([A-Z]+-\d+)/);
-        if (!match) {
-          const errorMessage = "Please provide an issueId to list comments for.";
-          await callback?.({
-            text: errorMessage,
-            source: message.content.source
-          });
-          return { text: errorMessage, success: false };
-        }
-        const extractedId = match[1];
-        const comments2 = await linearService.listComments(extractedId, limit, accountId);
-        return formatCommentResult(extractedId, comments2, message, callback);
-      }
-      const comments = await linearService.listComments(issueId, limit, accountId);
-      return formatCommentResult(issueId, comments, message, callback);
-    } catch (error) {
-      logger8.error("Failed to list comments:", error);
-      const errorMessage = `Failed to list comments: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({ text: errorMessage, source: message.content.source });
-      return { text: errorMessage, success: false };
-    }
-  }
-};
-async function formatCommentResult(issueId, comments, message, callback) {
-  if (comments.length === 0) {
-    const text2 = `No comments on issue ${issueId}.`;
-    await callback?.({ text: text2, source: message.content.source });
-    return { text: text2, success: true, data: { issueId, comments: [] } };
-  }
-  const lines = await Promise.all(comments.map(async (c) => {
-    const user = await c.user;
-    const name = user?.name ?? "unknown";
-    const created = c.createdAt ? new Date(c.createdAt).toISOString().slice(0, 10) : "?";
-    const body = (c.body ?? "").slice(0, 200);
-    return `- [${c.id}] ${name} (${created}): ${body}`;
-  }));
-  const text = `${comments.length} comment(s) on ${issueId}:
-${lines.join(`
-`)}`;
-  await callback?.({ text, source: message.content.source });
-  return {
-    text,
-    success: true,
-    data: {
-      issueId,
-      count: comments.length,
-      comments: comments.map((c) => ({ id: c.id }))
-    }
-  };
-}
-
-// src/actions/searchIssues.ts
-import {
-  logger as logger9,
-  ModelType as ModelType6
-} from "@elizaos/core";
-var searchTemplate = searchIssuesTemplate;
-var searchIssuesAction = {
-  name: "SEARCH_LINEAR_ISSUES",
-  contexts: ["tasks", "connectors", "knowledge"],
-  contextGate: { anyOf: ["tasks", "connectors", "knowledge"] },
-  roleGate: { minRole: "USER" },
-  description: "Search for issues in Linear with various filters",
-  descriptionCompressed: "search issue Linear w/ various filter",
-  similes: [
-    "search-linear-issues",
-    "find-linear-issues",
-    "query-linear-issues",
-    "list-linear-issues"
-  ],
-  parameters: [
-    {
-      name: "filters",
-      description: "Structured Linear issue filters: query, state, assignee, priority, team, label, and limit.",
-      required: false,
-      schema: { type: "object" }
-    },
-    {
-      name: "limit",
-      description: "Maximum number of issues to return.",
-      required: false,
-      schema: { type: "number" }
-    },
-    linearAccountIdParameter
-  ],
-  examples: [
-    [
-      {
-        name: "User",
-        content: {
-          text: "Show me all open bugs"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll search for all open bug issues in Linear.",
-          actions: ["SEARCH_LINEAR_ISSUES"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "What is John working on?"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll find the issues assigned to John.",
-          actions: ["SEARCH_LINEAR_ISSUES"]
-        }
-      }
-    ],
-    [
-      {
-        name: "User",
-        content: {
-          text: "Show me high priority issues created this week"
-        }
-      },
-      {
-        name: "Assistant",
-        content: {
-          text: "I'll search for high priority issues created this week.",
-          actions: ["SEARCH_LINEAR_ISSUES"]
-        }
-      }
-    ]
-  ],
-  validate: async (runtime, message, state) => validateLinearActionIntent(runtime, message, state, {
-    keywords: ["search", "linear", "issues"],
-    regexAlternation: "search|linear|issues"
-  }),
-  async handler(runtime, message, _state, _options, callback) {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        throw new Error("Linear service not available");
-      }
-      const accountId = getLinearAccountId(runtime, _options);
-      const content = message.content.text;
-      if (!content) {
-        const errorMessage = "Please provide search criteria for issues.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      let filters = {};
-      const params = _options?.parameters;
-      if (params?.filters) {
-        filters = params.filters;
-      } else {
-        const prompt = searchTemplate.replace("{{userMessage}}", content);
-        const response = await runtime.useModel(ModelType6.TEXT_LARGE, {
-          prompt
-        });
-        if (!response) {
-          filters = { query: content };
-        } else {
-          try {
-            const parsed = parseLinearPromptResponse(response);
-            if (Object.keys(parsed).length === 0) {
-              throw new Error("No fields found in model response");
-            }
-            filters = {
-              query: getStringValue(parsed.query),
-              limit: getNumberValue(parsed.limit) || 10
-            };
-            const states = getStringArrayValue(parsed.states);
-            if (states && states.length > 0) {
-              filters.state = states;
-            }
-            const assignees = getStringArrayValue(parsed.assignees);
-            if (assignees && assignees.length > 0) {
-              const processedAssignees = [];
-              for (const assignee of assignees) {
-                if (assignee.toLowerCase() === "me") {
-                  try {
-                    const currentUser = await linearService.getCurrentUser(accountId);
-                    processedAssignees.push(currentUser.email);
-                  } catch {
-                    logger9.warn('Could not resolve "me" to current user');
-                  }
-                } else {
-                  processedAssignees.push(assignee);
-                }
-              }
-              if (processedAssignees.length > 0) {
-                filters.assignee = processedAssignees;
-              }
-            }
-            if (getBooleanValue(parsed.hasAssignee) === false) {
-              filters.query = filters.query ? `${filters.query} unassigned` : "unassigned";
-            }
-            const parsedPriorities = getStringArrayValue(parsed.priorities);
-            if (parsedPriorities && parsedPriorities.length > 0) {
-              const priorityMap = {
-                urgent: 1,
-                high: 2,
-                normal: 3,
-                low: 4,
-                "1": 1,
-                "2": 2,
-                "3": 3,
-                "4": 4
-              };
-              const priorities = parsedPriorities.map((p) => priorityMap[p.toLowerCase()]).filter(Boolean);
-              if (priorities.length > 0) {
-                filters.priority = priorities;
-              }
-            }
-            const teams = getStringArrayValue(parsed.teams);
-            if (teams && teams.length > 0) {
-              filters.team = teams[0];
-            }
-            const labels = getStringArrayValue(parsed.labels);
-            if (labels && labels.length > 0) {
-              filters.label = labels;
-            }
-            Object.keys(filters).forEach((key) => {
-              if (filters[key] === undefined) {
-                delete filters[key];
-              }
-            });
-          } catch (parseError) {
-            logger9.error("Failed to parse search filters:", parseError);
-            filters = { query: content };
-          }
-        }
-      }
-      if (!filters.team) {
-        const defaultTeamKey = linearService.getDefaultTeamKey(accountId) ?? runtime.getSetting("LINEAR_DEFAULT_TEAM_KEY");
-        if (defaultTeamKey) {
-          const searchingAllIssues = content.toLowerCase().includes("all") && (content.toLowerCase().includes("issue") || content.toLowerCase().includes("bug") || content.toLowerCase().includes("task"));
-          if (!searchingAllIssues) {
-            filters.team = defaultTeamKey;
-            logger9.info(`Applying default team filter: ${defaultTeamKey}`);
-          }
-        }
-      }
-      filters.limit = params?.limit ?? filters.limit ?? 10;
-      const issues = await linearService.searchIssues(filters, accountId);
-      if (issues.length === 0) {
-        const noResultsMessage = "No issues found matching your search criteria.";
-        await callback?.({
-          text: noResultsMessage,
-          source: message.content.source
-        });
-        return {
-          text: noResultsMessage,
-          success: true,
-          data: {
-            issues: [],
-            filters: filters ? { ...filters } : undefined,
-            count: 0,
-            accountId
-          }
-        };
-      }
-      const issueList = await Promise.all(issues.map(async (issue, index) => {
-        const state = await issue.state;
-        const assignee = await issue.assignee;
-        const priorityLabels = ["", "Urgent", "High", "Normal", "Low"];
-        const priority = priorityLabels[issue.priority || 0] || "No priority";
-        return `${index + 1}. ${issue.identifier}: ${issue.title}
-   Status: ${state?.name || "No state"} | Priority: ${priority} | Assignee: ${assignee?.name || "Unassigned"}`;
-      }));
-      const issueText = issueList.join(`
-
-`);
-      const resultMessage = `\uD83D\uDCCB Found ${issues.length} issue${issues.length === 1 ? "" : "s"}:
-
-${issueText}`;
-      await callback?.({
-        text: resultMessage,
-        source: message.content.source
-      });
-      return {
-        text: `Found ${issues.length} issue${issues.length === 1 ? "" : "s"}`,
-        success: true,
-        data: {
-          issues: await Promise.all(issues.map(async (issue) => {
-            const state = await issue.state;
-            const assignee = await issue.assignee;
-            const team = await issue.team;
-            return {
-              id: issue.id,
-              identifier: issue.identifier,
-              title: issue.title,
-              url: issue.url,
-              priority: issue.priority,
-              state: state ? { name: state.name, type: state.type } : null,
-              assignee: assignee ? { name: assignee.name, email: assignee.email } : null,
-              team: team ? { name: team.name, key: team.key } : null,
-              createdAt: issue.createdAt instanceof Date ? issue.createdAt.toISOString() : issue.createdAt,
-              updatedAt: issue.updatedAt instanceof Date ? issue.updatedAt.toISOString() : issue.updatedAt
-            };
-          })),
-          filters: filters ? { ...filters } : undefined,
-          count: issues.length,
-          accountId
-        }
-      };
-    } catch (error) {
-      logger9.error("Failed to search issues:", error);
-      const errorMessage = `❌ Failed to search issues: ${error instanceof Error ? error.message : "Unknown error"}`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-  }
-};
-
-// src/actions/updateComment.ts
-import {
-  logger as logger10
-} from "@elizaos/core";
-async function handleUpdateComment(runtime, message, _state, _options, callback) {
-  try {
-    const linearService = runtime.getService("linear");
-    if (!linearService) {
-      throw new Error("Linear service not available");
-    }
-    const accountId = getLinearAccountId(runtime, _options);
-    const params = _options?.parameters;
-    const commentId = params?.commentId?.trim() ?? "";
-    const body = params?.body?.trim() ?? "";
-    if (!commentId || !body) {
-      const errorMessage = "Please provide both commentId and body to update a comment.";
-      await callback?.({ text: errorMessage, source: message.content.source });
-      return { text: errorMessage, success: false };
-    }
-    const comment = await linearService.updateComment(commentId, body, accountId);
-    const successMessage = `Updated comment ${commentId}.`;
-    await callback?.({ text: successMessage, source: message.content.source });
-    return {
-      text: successMessage,
-      success: true,
-      data: { commentId: comment.id, accountId }
-    };
-  } catch (error) {
-    logger10.error("Failed to update comment:", error);
-    const errorMessage = `Failed to update comment: ${error instanceof Error ? error.message : "Unknown error"}`;
-    await callback?.({ text: errorMessage, source: message.content.source });
-    return { text: errorMessage, success: false };
-  }
-}
-
-// src/actions/updateIssue.ts
-import {
-  logger as logger11,
-  ModelType as ModelType7
-} from "@elizaos/core";
-var LINEAR_MODEL_TIMEOUT_MS2 = 15000;
-var LINEAR_LOOKUP_LIMIT = 100;
-async function handleUpdateIssue(runtime, message, _state, _options, callback) {
-  try {
-    const linearService = runtime.getService("linear");
-    if (!linearService) {
-      throw new Error("Linear service not available");
-    }
-    const accountId = getLinearAccountId(runtime, _options);
-    const content = message.content.text;
-    if (!content) {
-      const errorMessage = "Please provide update instructions for the issue.";
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-    const prompt = updateIssueTemplate.replace("{{userMessage}}", content);
-    const response = await Promise.race([
-      runtime.useModel(ModelType7.TEXT_LARGE, {
-        prompt
-      }),
-      new Promise((_, reject) => setTimeout(() => reject(new Error("Linear update extraction timeout")), LINEAR_MODEL_TIMEOUT_MS2))
-    ]);
-    if (!response) {
-      throw new Error("Failed to extract update information");
-    }
-    let issueId;
-    const updates = {};
-    try {
-      const parsed = parseLinearPromptResponse(response);
-      if (Object.keys(parsed).length === 0) {
-        throw new Error("No fields found in model response");
-      }
-      issueId = getStringValue(parsed.issueId) ?? "";
-      if (!issueId) {
-        throw new Error("Issue ID not found in parsed response");
-      }
-      const parsedUpdates = getRecordValue(parsed.updates) ?? {};
-      const title = getStringValue(parsedUpdates.title);
-      if (title) {
-        updates.title = title;
-      }
-      const description = getStringValue(parsedUpdates.description);
-      if (description) {
-        updates.description = description;
-      }
-      const priority = getPriorityNumberValue(parsedUpdates.priority);
-      if (priority) {
-        updates.priority = priority;
-      }
-      const teamKey = getStringValue(parsedUpdates.teamKey);
-      if (teamKey) {
-        const teams = await linearService.getTeams(accountId);
-        const team = teams.slice(0, LINEAR_LOOKUP_LIMIT).find((t) => t.key.toLowerCase() === teamKey.toLowerCase());
-        if (team) {
-          updates.teamId = team.id;
-          logger11.info(`Moving issue to team: ${team.name} (${team.key})`);
-        } else {
-          logger11.warn(`Team with key ${teamKey} not found`);
-        }
-      }
-      const assignee = getStringValue(parsedUpdates.assignee);
-      if (assignee) {
-        const cleanAssignee = assignee.replace(/^@/, "");
-        const users = await linearService.getUsers(accountId);
-        const user = users.slice(0, LINEAR_LOOKUP_LIMIT).find((u) => u.email === cleanAssignee || u.name.toLowerCase().includes(cleanAssignee.toLowerCase()));
-        if (user) {
-          updates.assigneeId = user.id;
-        } else {
-          logger11.warn(`User ${cleanAssignee} not found`);
-        }
-      }
-      const status = getStringValue(parsedUpdates.status);
-      if (status) {
-        const issue = await linearService.getIssue(issueId, accountId);
-        const issueTeam = await issue.team;
-        const teamId = updates.teamId || issueTeam?.id;
-        if (!teamId) {
-          logger11.warn("Could not determine team for status update");
-        } else {
-          const states = await linearService.getWorkflowStates(teamId, accountId);
-          const state = states.slice(0, LINEAR_LOOKUP_LIMIT).find((s) => s.name.toLowerCase() === status.toLowerCase() || s.type.toLowerCase() === status.toLowerCase());
-          if (state) {
-            updates.stateId = state.id;
-            logger11.info(`Changing status to: ${state.name}`);
-          } else {
-            logger11.warn(`Status ${status} not found for team`);
-          }
-        }
-      }
-      const parsedLabels = getStringArrayValue(parsedUpdates.labels);
-      if (parsedLabels !== undefined) {
-        const teamId = updates.teamId;
-        const labels = await linearService.getLabels(teamId, accountId);
-        const labelIds = [];
-        for (const labelName of parsedLabels.slice(0, LINEAR_LOOKUP_LIMIT)) {
-          const label = labels.slice(0, LINEAR_LOOKUP_LIMIT).find((l) => l.name.toLowerCase() === labelName.toLowerCase());
-          if (label) {
-            labelIds.push(label.id);
-          }
-        }
-        updates.labelIds = labelIds;
-      }
-    } catch (parseError) {
-      logger11.warn("Failed to parse LLM response, falling back to regex parsing:", parseError);
-      const issueMatch = content.match(/(\w+-\d+)/);
-      if (!issueMatch) {
-        const errorMessage = "Please specify an issue ID (e.g., ENG-123) to update.";
-        await callback?.({
-          text: errorMessage,
-          source: message.content.source
-        });
-        return {
-          text: errorMessage,
-          success: false
-        };
-      }
-      issueId = issueMatch[1];
-      const titleMatch = content.match(/title to ["'](.+?)["']/i);
-      if (titleMatch) {
-        updates.title = titleMatch[1];
-      }
-      const priorityMatch = content.match(/priority (?:to |as )?(\w+)/i);
-      if (priorityMatch) {
-        const priorityMap = {
-          urgent: 1,
-          high: 2,
-          normal: 3,
-          medium: 3,
-          low: 4
-        };
-        const priority = priorityMap[priorityMatch[1].toLowerCase()];
-        if (priority) {
-          updates.priority = priority;
-        }
-      }
-    }
-    if (Object.keys(updates).length === 0) {
-      const errorMessage = `No valid updates found. Please specify what to update (e.g., "Update issue ENG-123 title to 'New Title'")`;
-      await callback?.({
-        text: errorMessage,
-        source: message.content.source
-      });
-      return {
-        text: errorMessage,
-        success: false
-      };
-    }
-    const updatedIssue = await linearService.updateIssue(issueId, updates, accountId);
-    const updateSummary = [];
-    if (updates.title)
-      updateSummary.push(`title: "${updates.title}"`);
-    if (updates.priority)
-      updateSummary.push(`priority: ${["", "urgent", "high", "normal", "low"][updates.priority]}`);
-    if (updates.teamId)
-      updateSummary.push(`moved to team`);
-    if (updates.assigneeId)
-      updateSummary.push(`assigned to user`);
-    if (updates.stateId)
-      updateSummary.push(`status changed`);
-    if (updates.labelIds)
-      updateSummary.push(`labels updated`);
-    const successMessage = `✅ Updated issue ${updatedIssue.identifier}: ${updateSummary.join(", ")}
-
-View it at: ${updatedIssue.url}`;
-    await callback?.({
-      text: successMessage,
-      source: message.content.source
-    });
-    return {
-      text: `Updated issue ${updatedIssue.identifier}: ${updateSummary.join(", ")}`,
-      success: true,
-      data: {
-        issueId: updatedIssue.id,
-        identifier: updatedIssue.identifier,
-        updates: updates ? Object.fromEntries(Object.entries(updates).map(([key, value]) => [
-          key,
-          value instanceof Date ? value.toISOString() : value
-        ])) : undefined,
-        url: updatedIssue.url,
-        accountId
-      }
-    };
-  } catch (error) {
-    logger11.error("Failed to update issue:", error);
-    const errorMessage = `❌ Failed to update issue: ${error instanceof Error ? error.message : "Unknown error"}`;
-    await callback?.({
-      text: errorMessage,
-      source: message.content.source
-    });
-    return {
-      text: errorMessage,
-      success: false
-    };
-  }
-}
-
-// src/actions/linear.ts
-var LINEAR_CONTEXT = "linear";
-var ALL_OPS = [
-  "create_issue",
-  "get_issue",
-  "update_issue",
-  "delete_issue",
-  "create_comment",
-  "update_comment",
-  "delete_comment",
-  "list_comments",
-  "get_activity",
-  "clear_activity",
-  "search_issues"
-];
-var ROUTES = [
-  {
-    op: "delete_issue",
-    action: deleteIssueAction,
-    match: /\b(delete|archive|remove|close)\b.*\b(issue|bug|task|ticket|[a-z]+-\d+)\b/i
-  },
-  {
-    op: "update_issue",
-    run: handleUpdateIssue,
-    match: /\b(update|edit|modify|move|change|assign|reassign|priority|status|label)\b.*\b(issue|bug|task|ticket|[a-z]+-\d+)\b/i
-  },
-  {
-    op: "create_issue",
-    action: createIssueAction,
-    match: /\b(create|new|add|file|open)\b.*\b(issue|bug|task|ticket|linear)\b|\b(issue|bug|task|ticket)\b.*\b(create|new|add|file|open)\b/i
-  },
-  {
-    op: "create_comment",
-    action: createCommentAction,
-    match: /\b(comment|reply|note|tell)\b.*\b(issue|bug|task|ticket|[a-z]+-\d+)\b/i
-  },
-  {
-    op: "update_comment",
-    run: handleUpdateComment,
-    match: /\b(update|edit|modify|change)\b.*\bcomment\b/i
-  },
-  {
-    op: "delete_comment",
-    action: deleteCommentAction,
-    match: /\b(delete|remove|erase)\b.*\bcomment\b/i
-  },
-  {
-    op: "list_comments",
-    action: listCommentsAction,
-    match: /\b(list|show|get|fetch|view)\b.*\bcomments?\b|\bcomments?\b.*\b(list|show|get|fetch)\b/i
-  },
-  {
-    op: "clear_activity",
-    action: clearActivityAction,
-    match: /\b(clear|reset|delete)\b.*\b(activity|activity log)\b/i
-  },
-  {
-    op: "get_activity",
-    action: getActivityAction,
-    match: /\b(activity|activity log|what happened|recent changes|audit)\b/i
-  },
-  {
-    op: "search_issues",
-    action: searchIssuesAction,
-    match: /\b(search|find|query|list|show)\b.*\b(issues?|bugs?|tasks?|tickets?)\b|\b(open|closed|unassigned|assigned|high priority|blockers?)\b.*\b(issues?|bugs?|tasks?|tickets?)\b/i
-  },
-  {
-    op: "get_issue",
-    action: getIssueAction,
-    match: /\b(show|get|view|check|details?|status|what'?s|find)\b.*\b(issue|bug|task|ticket|[a-z]+-\d+)\b|[a-z]+-\d+/i
-  }
-];
-function textOf(message) {
-  return typeof message.content?.text === "string" ? message.content.text : "";
-}
-function readOptions(options) {
-  const direct = options ?? {};
-  const parameters = direct.parameters && typeof direct.parameters === "object" ? direct.parameters : {};
-  return { ...direct, ...parameters };
-}
-function normalizeOp(value) {
-  if (typeof value !== "string")
-    return null;
-  const trimmed = value.trim().toLowerCase().replace(/[\s-]+/g, "_");
-  return ALL_OPS.includes(trimmed) ? trimmed : null;
-}
-function selectRoute(message, options) {
-  const opts = readOptions(options);
-  const requested = normalizeOp(opts.action ?? opts.subaction ?? opts.op);
-  if (requested) {
-    const route = ROUTES.find((candidate) => candidate.op === requested);
-    if (route)
-      return route;
-  }
-  const text = textOf(message);
-  return ROUTES.find((route) => route.match.test(text)) ?? null;
-}
-function hasLinearAccess(runtime) {
-  return hasLinearAccountConfig(runtime);
-}
-var linearAction = {
-  name: "LINEAR",
-  description: "Manage Linear issues, comments, and activity. Operations: create_issue, get_issue, update_issue, delete_issue, create_comment, update_comment, delete_comment, list_comments, get_activity, clear_activity, search_issues. The op is inferred from the message text when not explicitly provided.",
-  descriptionCompressed: "Linear: create/get/update/delete issue, create/update/delete/list comment, search issues, get/clear activity.",
-  similes: [
-    "LINEAR_ISSUE",
-    "LINEAR_ISSUES",
-    "LINEAR_COMMENT",
-    "LINEAR_COMMENTS",
-    "LINEAR_WORKFLOW",
-    "LINEAR_ACTIVITY",
-    "LINEAR_SEARCH",
-    "CREATE_LINEAR_ISSUE",
-    "GET_LINEAR_ISSUE",
-    "UPDATE_LINEAR_ISSUE",
-    "DELETE_LINEAR_ISSUE",
-    "MANAGE_LINEAR_ISSUE",
-    "MANAGE_LINEAR_ISSUES",
-    "CREATE_LINEAR_COMMENT",
-    "COMMENT_LINEAR_ISSUE",
-    "UPDATE_LINEAR_COMMENT",
-    "DELETE_LINEAR_COMMENT",
-    "LIST_LINEAR_COMMENTS",
-    "GET_LINEAR_ACTIVITY",
-    "CLEAR_LINEAR_ACTIVITY",
-    "SEARCH_LINEAR_ISSUES",
-    "LINEAR_WORKFLOW_SEARCH"
-  ],
-  contexts: ["general", "automation", "knowledge", LINEAR_CONTEXT],
-  contextGate: { anyOf: ["general", "automation", "knowledge", LINEAR_CONTEXT] },
-  roleGate: { minRole: "USER" },
-  parameters: [
-    {
-      name: "action",
-      description: "Operation to perform. One of: create_issue, get_issue, update_issue, delete_issue, create_comment, update_comment, delete_comment, list_comments, get_activity, clear_activity, search_issues. Inferred from message text when omitted.",
-      required: false,
-      schema: { type: "string", enum: [...ALL_OPS] }
-    },
-    linearAccountIdParameter
-  ],
-  validate: async (runtime) => {
-    if (!hasLinearAccess(runtime))
-      return false;
-    return true;
-  },
-  handler: async (runtime, message, state, options, callback) => {
-    const route = selectRoute(message, options);
-    if (!route) {
-      const ops = ALL_OPS.join(", ");
-      const text = `LINEAR could not determine the operation. Specify one of: ${ops}.`;
-      await callback?.({ text, source: message.content?.source });
-      return {
-        success: false,
-        text,
-        values: { error: "MISSING" },
-        data: { actionName: "LINEAR", availableOps: ops }
-      };
-    }
-    const dispatch = route.run ?? route.action?.handler?.bind(route.action);
-    const result = dispatch ? await dispatch(runtime, message, state, options, callback) ?? { success: true } : { success: true };
-    return {
-      ...result,
-      data: {
-        ...typeof result.data === "object" && result.data ? result.data : {},
-        actionName: "LINEAR",
-        routedActionName: route.action?.name ?? route.op,
-        op: route.op
-      }
-    };
-  },
-  examples: [
-    [
-      { name: "{{user1}}", content: { text: "Create a Linear issue for the mobile login bug" } },
-      {
-        name: "{{agentName}}",
-        content: {
-          text: "I'll create that Linear issue.",
-          actions: ["LINEAR"]
-        }
-      }
-    ],
-    [
-      { name: "{{user1}}", content: { text: "Comment on ENG-123 that QA can retest it" } },
-      {
-        name: "{{agentName}}",
-        content: { text: "I'll add that comment to ENG-123.", actions: ["LINEAR"] }
-      }
-    ],
-    [
-      { name: "{{user1}}", content: { text: "Search open Linear bugs for the backend team" } },
-      {
-        name: "{{agentName}}",
-        content: { text: "I'll search Linear issues.", actions: ["LINEAR"] }
-      }
-    ],
-    [
-      { name: "{{user1}}", content: { text: "What's the status of ENG-456?" } },
-      {
-        name: "{{agentName}}",
-        content: { text: "Looking up ENG-456.", actions: ["LINEAR"] }
-      }
-    ]
-  ]
-};
-
-// src/connector-account-provider.ts
-import {
-  logger as logger12
-} from "@elizaos/core";
-var LINEAR_PROVIDER_NAME = "linear";
-var LINEAR_AUTHORIZATION_ENDPOINT = "https://linear.app/oauth/authorize";
-var LINEAR_TOKEN_ENDPOINT = "https://api.linear.app/oauth/token";
-var LINEAR_GRAPHQL_ENDPOINT = "https://api.linear.app/graphql";
-var DEFAULT_PURPOSES = ["admin"];
-function nonEmptyString2(value) {
-  if (typeof value !== "string")
-    return;
-  const trimmed = value.trim();
-  return trimmed.length > 0 ? trimmed : undefined;
-}
-function readSetting2(runtime, key) {
-  return nonEmptyString2(runtime.getSetting?.(key));
-}
-function readClientConfig(runtime) {
-  const clientId = readSetting2(runtime, "LINEAR_OAUTH_CLIENT_ID");
-  const clientSecret = readSetting2(runtime, "LINEAR_OAUTH_CLIENT_SECRET");
-  const redirectUri = readSetting2(runtime, "LINEAR_OAUTH_REDIRECT_URI");
-  if (!clientId || !clientSecret || !redirectUri) {
-    throw new Error("Linear OAuth requires LINEAR_OAUTH_CLIENT_ID, LINEAR_OAUTH_CLIENT_SECRET, and LINEAR_OAUTH_REDIRECT_URI to be configured.");
-  }
-  return { clientId, clientSecret, redirectUri };
-}
-function parseScopes(value) {
-  if (!value)
-    return [];
-  return value.split(/[,\s]+/).map((scope) => scope.trim()).filter(Boolean);
-}
-async function exchangeCodeForToken(args) {
-  const response = await fetch(LINEAR_TOKEN_ENDPOINT, {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/x-www-form-urlencoded",
-      Accept: "application/json"
-    },
-    body: new URLSearchParams({
-      client_id: args.clientId,
-      client_secret: args.clientSecret,
-      code: args.code,
-      redirect_uri: args.redirectUri,
-      grant_type: "authorization_code"
-    }).toString()
-  });
-  if (!response.ok) {
-    const body = await response.text();
-    throw new Error(`Linear token exchange failed with ${response.status}: ${body}`);
-  }
-  const parsed = await response.json();
-  if (parsed.error) {
-    throw new Error(`Linear token exchange returned error ${parsed.error}: ${parsed.error_description ?? "no description"}`);
-  }
-  if (!parsed.access_token) {
-    throw new Error("Linear token exchange returned no access_token.");
-  }
-  return parsed;
-}
-async function fetchLinearViewer(accessToken) {
-  const response = await fetch(LINEAR_GRAPHQL_ENDPOINT, {
-    method: "POST",
-    headers: {
-      Authorization: `Bearer ${accessToken}`,
-      "Content-Type": "application/json"
-    },
-    body: JSON.stringify({
-      query: "{ viewer { id name email organization { id name urlKey } } }"
-    })
-  });
-  if (!response.ok) {
-    throw new Error(`Linear viewer query failed with ${response.status}`);
-  }
-  return await response.json();
-}
-function synthesizeEnvAccounts(runtime) {
-  const now = Date.now();
-  return readLinearAccounts(runtime).map((account) => ({
-    id: account.accountId,
-    provider: LINEAR_PROVIDER_NAME,
-    label: account.label ?? `Linear (${account.accountId})`,
-    role: "OWNER",
-    purpose: DEFAULT_PURPOSES,
-    accessGate: "open",
-    status: "connected",
-    externalId: account.workspaceId,
-    displayHandle: account.workspaceId ?? account.accountId,
-    createdAt: now,
-    updatedAt: now,
-    metadata: {
-      authMethod: "api_key",
-      source: "env",
-      defaultTeamKey: account.defaultTeamKey ?? null
-    }
-  }));
-}
-function createLinearConnectorAccountProvider(runtime) {
-  return {
-    provider: LINEAR_PROVIDER_NAME,
-    label: "Linear",
-    listAccounts: async (manager) => {
-      const stored = await manager.getStorage().listAccounts(LINEAR_PROVIDER_NAME);
-      if (stored.length > 0)
-        return stored;
-      return synthesizeEnvAccounts(runtime);
-    },
-    createAccount: async (input, _manager) => {
-      return {
-        ...input,
-        provider: LINEAR_PROVIDER_NAME,
-        role: input.role ?? "OWNER",
-        purpose: input.purpose ?? DEFAULT_PURPOSES,
-        accessGate: input.accessGate ?? "open",
-        status: input.status ?? "pending"
-      };
-    },
-    patchAccount: async (_accountId, patch, _manager) => {
-      return { ...patch, provider: LINEAR_PROVIDER_NAME };
-    },
-    deleteAccount: async (_accountId, _manager) => {},
-    startOAuth: async (request, _manager) => {
-      const config = readClientConfig(runtime);
-      const redirectUri = request.redirectUri ?? config.redirectUri;
-      const scopes = request.scopes && request.scopes.length > 0 ? request.scopes : ["read", "write", "issues:create", "comments:create"];
-      const params = new URLSearchParams({
-        client_id: config.clientId,
-        redirect_uri: redirectUri,
-        response_type: "code",
-        scope: scopes.join(","),
-        state: request.flow.state,
-        prompt: "consent"
-      });
-      return {
-        authUrl: `${LINEAR_AUTHORIZATION_ENDPOINT}?${params.toString()}`,
-        metadata: {
-          ...request.metadata,
-          requestedScopes: scopes,
-          redirectUri
-        }
-      };
-    },
-    completeOAuth: async (request, _manager) => {
-      const code = nonEmptyString2(request.code);
-      if (!code) {
-        throw new Error("Linear OAuth callback is missing an authorization code.");
-      }
-      const config = readClientConfig(runtime);
-      const redirectUri = nonEmptyString2(request.flow.redirectUri) ?? config.redirectUri;
-      const tokens = await exchangeCodeForToken({
-        clientId: config.clientId,
-        clientSecret: config.clientSecret,
-        redirectUri,
-        code
-      });
-      if (!tokens.access_token) {
-        throw new Error("Linear token exchange returned no access_token.");
-      }
-      const viewerPayload = await fetchLinearViewer(tokens.access_token);
-      const viewer = viewerPayload.data?.viewer;
-      const organization = viewer?.organization;
-      const workspaceId = nonEmptyString2(organization?.id);
-      const workspaceHandle = nonEmptyString2(organization?.urlKey);
-      const externalId = workspaceId ?? workspaceHandle;
-      if (!externalId) {
-        throw new Error("Linear viewer payload did not include an organization id or urlKey.");
-      }
-      const accountPatch = {
-        provider: LINEAR_PROVIDER_NAME,
-        role: "OWNER",
-        purpose: DEFAULT_PURPOSES,
-        accessGate: "open",
-        status: "connected",
-        externalId,
-        displayHandle: workspaceHandle ?? externalId,
-        label: nonEmptyString2(organization?.name) ?? nonEmptyString2(workspaceHandle) ?? "Linear",
-        metadata: {
-          authMethod: "oauth",
-          workspaceId: workspaceId ?? null,
-          workspaceHandle: workspaceHandle ?? null,
-          workspaceName: nonEmptyString2(organization?.name) ?? null,
-          viewerId: nonEmptyString2(viewer?.id) ?? null,
-          viewerEmail: nonEmptyString2(viewer?.email) ?? null,
-          viewerName: nonEmptyString2(viewer?.name) ?? null,
-          tokenType: nonEmptyString2(tokens.token_type) ?? "bearer",
-          grantedScopes: parseScopes(tokens.scope),
-          hasRefreshToken: Boolean(tokens.refresh_token)
-        }
-      };
-      logger12.info({
-        src: "plugin:linear:connector",
-        workspaceId: workspaceId ?? null,
-        workspaceHandle: workspaceHandle ?? null
-      }, "Linear OAuth completed");
-      return {
-        account: accountPatch,
-        flow: { status: "completed" }
-      };
-    }
-  };
-}
-
-// src/providers/activity.ts
-function formatDetails(details) {
-  if (details === null || details === undefined) {
-    return "none";
-  }
-  if (Array.isArray(details)) {
-    return details.map(formatDetails).join(", ");
-  }
-  if (typeof details !== "object") {
-    return String(details);
-  }
-  return Object.entries(details).map(([key, value]) => `${key}: ${formatDetails(value)}`).join("; ");
-}
-var linearActivityProvider = {
-  name: "LINEAR_ACTIVITY",
-  description: "Provides context about recent Linear activity",
-  descriptionCompressed: "provide context recent Linear activity",
-  dynamic: true,
-  contexts: ["automation", "connectors"],
-  contextGate: { anyOf: ["automation", "connectors"] },
-  cacheScope: "turn",
-  roleGate: { minRole: "ADMIN" },
-  get: async (runtime, _message, _state) => {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        return {
-          text: "Linear service is not available"
-        };
-      }
-      const activity = linearService.getActivityLog(10);
-      if (activity.length === 0) {
-        return {
-          text: "No recent Linear activity"
-        };
-      }
-      const activityList = activity.map((item) => {
-        const status = item.success ? "✓" : "✗";
-        const time = new Date(item.timestamp).toLocaleTimeString();
-        return `${status} ${time}: ${item.action} ${item.resource_type} ${item.resource_id}`;
-      });
-      const text = `Recent Linear Activity:
-${activityList.join(`
-`)}`;
-      return {
-        text,
-        data: {
-          activity: activity.slice(0, 10).map((item) => ({
-            id: item.id,
-            action: item.action,
-            resource_type: item.resource_type,
-            resource_id: item.resource_id,
-            success: item.success,
-            error: item.error,
-            details: formatDetails(item.details),
-            timestamp: typeof item.timestamp === "string" ? item.timestamp : new Date(item.timestamp).toISOString()
-          }))
-        }
-      };
-    } catch (_error) {
-      return {
-        text: "Error retrieving Linear activity"
-      };
-    }
-  }
-};
-
-// src/providers/issues.ts
-var linearIssuesProvider = {
-  name: "LINEAR_ISSUES",
-  description: "Provides context about recent Linear issues",
-  descriptionCompressed: "provide context recent Linear issue",
-  dynamic: true,
-  contexts: ["automation", "connectors"],
-  contextGate: { anyOf: ["automation", "connectors"] },
-  cacheScope: "turn",
-  roleGate: { minRole: "ADMIN" },
-  get: async (runtime, _message, _state) => {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        return {
-          text: "Linear service is not available"
-        };
-      }
-      const issues = await linearService.searchIssues({ limit: 10 });
-      if (issues.length === 0) {
-        return {
-          text: "No recent Linear issues found"
-        };
-      }
-      const issuesList = await Promise.all(issues.map(async (issue) => {
-        const [assignee, state] = await Promise.all([issue.assignee, issue.state]);
-        return `- ${issue.identifier}: ${issue.title} (${state?.name || "Unknown"}, ${assignee?.name || "Unassigned"})`;
-      }));
-      const text = `Recent Linear Issues:
-${issuesList.join(`
-`)}`;
-      return {
-        text,
-        data: {
-          issues: issues.map((issue) => ({
-            id: issue.id,
-            identifier: issue.identifier,
-            title: issue.title
-          }))
-        }
-      };
-    } catch (_error) {
-      return {
-        text: "Error retrieving Linear issues"
-      };
-    }
-  }
-};
-
-// src/providers/projects.ts
-var linearProjectsProvider = {
-  name: "LINEAR_PROJECTS",
-  description: "Provides context about active Linear projects",
-  descriptionCompressed: "provide context active Linear project",
-  dynamic: true,
-  contexts: ["automation", "connectors"],
-  contextGate: { anyOf: ["automation", "connectors"] },
-  cacheScope: "agent",
-  roleGate: { minRole: "ADMIN" },
-  get: async (runtime, _message, _state) => {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        return {
-          text: "Linear service is not available"
-        };
-      }
-      const projects = await linearService.getProjects();
-      if (projects.length === 0) {
-        return {
-          text: "No Linear projects found"
-        };
-      }
-      const activeProjects = projects.filter((project) => project.state === "started" || project.state === "planned");
-      const projectsList = activeProjects.slice(0, 10).map((project) => `- ${project.name}: ${project.state} (${project.startDate || "No start date"} - ${project.targetDate || "No target date"})`);
-      const text = `Active Linear Projects:
-${projectsList.join(`
-`)}`;
-      return {
-        text,
-        data: {
-          projects: activeProjects.slice(0, 10).map((project) => ({
-            id: project.id,
-            name: project.name,
-            state: project.state
-          }))
-        }
-      };
-    } catch (_error) {
-      return {
-        text: "Error retrieving Linear projects"
-      };
-    }
-  }
-};
-
-// src/providers/teams.ts
-var MAX_LINEAR_TEAMS = 20;
-var MAX_DESCRIPTION_CHARS = 180;
-var linearTeamsProvider = {
-  name: "LINEAR_TEAMS",
-  description: "Provides context about Linear teams",
-  descriptionCompressed: "provide context Linear team",
-  dynamic: true,
-  contexts: ["automation", "connectors"],
-  contextGate: { anyOf: ["automation", "connectors"] },
-  cacheScope: "agent",
-  roleGate: { minRole: "ADMIN" },
-  get: async (runtime, _message, _state) => {
-    try {
-      const linearService = runtime.getService("linear");
-      if (!linearService) {
-        return {
-          text: "Linear service is not available"
-        };
-      }
-      const teams = await linearService.getTeams();
-      const listedTeams = teams.slice(0, MAX_LINEAR_TEAMS);
-      if (teams.length === 0) {
-        return {
-          text: "No Linear teams found"
-        };
-      }
-      const teamsList = listedTeams.map((team) => `- ${team.name} (${team.key}): ${(team.description || "No description").slice(0, MAX_DESCRIPTION_CHARS)}`);
-      const text = `Linear Teams:
-${teamsList.join(`
-`)}`;
-      return {
-        text,
-        data: {
-          teams: listedTeams.map((team) => ({
-            id: team.id,
-            name: team.name,
-            key: team.key
-          })),
-          truncated: teams.length > listedTeams.length
-        }
-      };
-    } catch (_error) {
-      return {
-        text: "Error retrieving Linear teams"
-      };
-    }
-  }
-};
-
-// src/search-category.ts
-var LINEAR_ISSUES_SEARCH_CATEGORY = {
-  category: "linear_issues",
-  label: "Linear issues",
-  description: "Search Linear issues by text and issue metadata filters.",
-  contexts: ["automation", "system"],
-  filters: [
-    { name: "query", label: "Query", type: "string", required: true },
-    {
-      name: "state",
-      label: "States",
-      description: "Issue workflow state names.",
-      type: "string[]"
-    },
-    {
-      name: "assignee",
-      label: "Assignees",
-      description: "Assignee names or emails.",
-      type: "string[]"
-    },
-    {
-      name: "label",
-      label: "Labels",
-      description: "Linear issue label names.",
-      type: "string[]"
-    },
-    {
-      name: "project",
-      label: "Project",
-      description: "Linear project name or identifier.",
-      type: "string"
-    },
-    {
-      name: "team",
-      label: "Team",
-      description: "Linear team key, name, or identifier.",
-      type: "string"
-    },
-    {
-      name: "priority",
-      label: "Priorities",
-      description: "Linear priorities: 1 urgent, 2 high, 3 normal, 4 low.",
-      type: "number[]"
-    },
-    {
-      name: "limit",
-      label: "Limit",
-      description: "Maximum issues to return.",
-      type: "number",
-      default: 10
-    },
-    {
-      name: "accountId",
-      label: "Account",
-      description: "Optional Linear account id. Defaults to LINEAR_DEFAULT_ACCOUNT_ID or the legacy single API key.",
-      type: "string"
-    }
-  ],
-  resultSchemaSummary: "LinearIssue[] with id, identifier, title, description, state, assignee, labels, priority, team, project, url, and updatedAt.",
-  capabilities: ["issues", "filters", "workflow", "team"],
-  source: "plugin:linear",
-  serviceType: "linear"
-};
-function hasSearchCategory(runtime, category) {
-  try {
-    runtime.getSearchCategory(category, { includeDisabled: true });
-    return true;
-  } catch {
-    return false;
-  }
-}
-function registerLinearSearchCategory(runtime) {
-  if (!hasSearchCategory(runtime, LINEAR_ISSUES_SEARCH_CATEGORY.category)) {
-    runtime.registerSearchCategory(LINEAR_ISSUES_SEARCH_CATEGORY);
-  }
-}
-
-// src/services/linear.ts
-import { logger as logger13, Service } from "@elizaos/core";
-import {
-  LinearClient
-} from "@linear/sdk";
-
-// src/types/index.ts
-class LinearAPIError extends Error {
-  status;
-  response;
-  constructor(message, status, response) {
-    super(message);
-    this.status = status;
-    this.response = response;
-    this.name = "LinearAPIError";
-  }
-}
-
-class LinearAuthenticationError extends LinearAPIError {
-  constructor(message) {
-    super(message, 401);
-    this.name = "LinearAuthenticationError";
-  }
-}
-
-// src/services/linear.ts
-class LinearService extends Service {
-  static serviceType = "linear";
-  capabilityDescription = "Linear API integration for issue tracking, project management, and team collaboration";
-  clients = new Map;
-  activityLog = [];
-  defaultAccountId = DEFAULT_LINEAR_ACCOUNT_ID;
-  workspaceId;
-  constructor(runtime) {
-    super(runtime);
-    const accounts = runtime ? readLinearAccounts(runtime) : [];
-    const requestedDefault = runtime ? normalizeLinearAccountId(runtime.getSetting("LINEAR_DEFAULT_ACCOUNT_ID") ?? runtime.getSetting("LINEAR_ACCOUNT_ID")) : DEFAULT_LINEAR_ACCOUNT_ID;
-    const defaultAccount = resolveLinearDefaultAccount(accounts, requestedDefault);
-    if (!defaultAccount) {
-      throw new LinearAuthenticationError("Linear API key is required");
-    }
-    this.defaultAccountId = defaultAccount.accountId;
-    this.workspaceId = defaultAccount.workspaceId;
-    for (const account of accounts) {
-      this.clients.set(account.accountId, {
-        accountId: account.accountId,
-        config: account,
-        client: new LinearClient({ apiKey: account.apiKey })
-      });
-    }
-  }
-  static async start(runtime) {
-    const service = new LinearService(runtime);
-    await service.validateConnection();
-    logger13.info("Linear service started successfully");
-    return service;
-  }
-  async stop() {
-    this.activityLog = [];
-    logger13.info("Linear service stopped");
-  }
-  async validateConnection(accountId) {
-    try {
-      const state = this.getAccountState(accountId);
-      const viewer = await state.client.viewer;
-      logger13.info(`Linear connected as user: ${viewer.email} (accountId=${state.accountId})`);
-    } catch (_error) {
-      throw new LinearAuthenticationError("Failed to authenticate with Linear API");
-    }
-  }
-  hasAccount(accountId) {
-    return Boolean(this.getAccountState(accountId, false));
-  }
-  getDefaultTeamKey(accountId) {
-    return this.getAccountState(accountId).config.defaultTeamKey;
-  }
-  getAccountState(accountId, throwOnMissing = true) {
-    const normalized = normalizeLinearAccountId(accountId);
-    const state = accountId ? this.clients.get(normalized) ?? null : this.clients.get(this.defaultAccountId) ?? Array.from(this.clients.values())[0] ?? null;
-    if (!state && throwOnMissing) {
-      throw new LinearAuthenticationError("Linear API key is required");
-    }
-    return state;
-  }
-  getClient(accountId) {
-    return this.getAccountState(accountId)?.client;
-  }
-  logActivity(action, resourceType, resourceId, details, success, error) {
-    const activity = {
-      id: `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`,
-      timestamp: new Date().toISOString(),
-      action,
-      resource_type: resourceType,
-      resource_id: resourceId,
-      details,
-      success,
-      error
-    };
-    this.activityLog.push(activity);
-    if (this.activityLog.length > 1000) {
-      this.activityLog = this.activityLog.slice(-1000);
-    }
-  }
-  getActivityLog(limit, filter, accountId) {
-    let filtered = [...this.activityLog];
-    if (filter) {
-      filtered = filtered.filter((item) => {
-        return Object.entries(filter).every(([key, value]) => {
-          return item[key] === value;
-        });
-      });
-    }
-    if (accountId) {
-      filtered = filtered.filter((item) => item.details.accountId === accountId);
-    }
-    return filtered.slice(-(limit || 100));
-  }
-  clearActivityLog(accountId) {
-    if (accountId) {
-      this.activityLog = this.activityLog.filter((item) => item.details.accountId !== accountId);
-      logger13.info(`Linear activity log cleared for accountId=${accountId}`);
-      return;
-    }
-    this.activityLog = [];
-    logger13.info("Linear activity log cleared");
-  }
-  async getTeams(accountId) {
-    const state = this.getAccountState(accountId);
-    const teams = await state.client.teams();
-    const teamList = await teams.nodes;
-    this.logActivity("list_teams", "team", "all", { count: teamList.length, accountId: state.accountId }, true);
-    return teamList;
-  }
-  async getTeam(teamId, accountId) {
-    const state = this.getAccountState(accountId);
-    const team = await state.client.team(teamId);
-    this.logActivity("get_team", "team", teamId, { name: team.name, accountId: state.accountId }, true);
-    return team;
-  }
-  async createIssue(input, accountId) {
-    const state = this.getAccountState(accountId);
-    const issuePayload = await state.client.createIssue({
-      title: input.title,
-      description: input.description,
-      teamId: input.teamId,
-      priority: input.priority,
-      assigneeId: input.assigneeId,
-      labelIds: input.labelIds,
-      projectId: input.projectId,
-      stateId: input.stateId,
-      estimate: input.estimate,
-      dueDate: input.dueDate
-    });
-    const issue = await issuePayload.issue;
-    if (!issue) {
-      throw new Error("Failed to create issue");
-    }
-    this.logActivity("create_issue", "issue", issue.id, {
-      title: input.title,
-      teamId: input.teamId,
-      accountId: state.accountId
-    }, true);
-    return issue;
-  }
-  async getIssue(issueId, accountId) {
-    const state = this.getAccountState(accountId);
-    const issue = await state.client.issue(issueId);
-    this.logActivity("get_issue", "issue", issueId, {
-      title: issue.title,
-      identifier: issue.identifier,
-      accountId: state.accountId
-    }, true);
-    return issue;
-  }
-  async updateIssue(issueId, updates, accountId) {
-    const state = this.getAccountState(accountId);
-    const updatePayload = await state.client.updateIssue(issueId, {
-      title: updates.title,
-      description: updates.description,
-      priority: updates.priority,
-      assigneeId: updates.assigneeId,
-      labelIds: updates.labelIds,
-      projectId: updates.projectId,
-      stateId: updates.stateId,
-      estimate: updates.estimate,
-      dueDate: updates.dueDate
-    });
-    const issue = await updatePayload.issue;
-    if (!issue) {
-      throw new Error("Failed to update issue");
-    }
-    this.logActivity("update_issue", "issue", issueId, { ...updates, accountId: state.accountId }, true);
-    return issue;
-  }
-  async deleteIssue(issueId, accountId) {
-    const state = this.getAccountState(accountId);
-    const archivePayload = await state.client.archiveIssue(issueId);
-    const success = await archivePayload.success;
-    if (!success) {
-      throw new Error("Failed to archive issue");
-    }
-    this.logActivity("delete_issue", "issue", issueId, { action: "archived", accountId: state.accountId }, true);
-  }
-  async searchIssues(filters, accountId) {
-    const state = this.getAccountState(accountId);
-    const filterObject = {};
-    if (filters.query) {
-      filterObject.or = [
-        { title: { containsIgnoreCase: filters.query } },
-        { description: { containsIgnoreCase: filters.query } }
-      ];
-    }
-    if (filters.team) {
-      const teams = await this.getTeams(state.accountId);
-      const team = teams.find((t) => t.key.toLowerCase() === filters.team?.toLowerCase() || t.name.toLowerCase() === filters.team?.toLowerCase());
-      if (team) {
-        filterObject.team = { id: { eq: team.id } };
-      }
-    }
-    if (filters.assignee && filters.assignee.length > 0) {
-      const users = await this.getUsers(state.accountId);
-      const assigneeIds = filters.assignee.map((assigneeName) => {
-        const user = users.find((u) => u.email === assigneeName || u.name.toLowerCase().includes(assigneeName.toLowerCase()));
-        return user?.id;
-      }).filter(Boolean);
-      if (assigneeIds.length > 0) {
-        filterObject.assignee = { id: { in: assigneeIds } };
-      }
-    }
-    if (filters.priority && filters.priority.length > 0) {
-      filterObject.priority = { number: { in: filters.priority } };
-    }
-    if (filters.state && filters.state.length > 0) {
-      filterObject.state = {
-        name: { in: filters.state }
-      };
-    }
-    if (filters.label && filters.label.length > 0) {
-      filterObject.labels = {
-        some: {
-          name: { in: filters.label }
-        }
-      };
-    }
-    const query = state.client.issues({
-      first: filters.limit || 50,
-      filter: Object.keys(filterObject).length > 0 ? filterObject : undefined
-    });
-    const issues = await query;
-    const issueList = await issues.nodes;
-    this.logActivity("search_issues", "issue", "search", {
-      filters: { ...filters, accountId: state.accountId },
-      count: issueList.length
-    }, true);
-    return issueList;
-  }
-  async createComment(input, accountId) {
-    const state = this.getAccountState(accountId);
-    const commentPayload = await state.client.createComment({
-      body: input.body,
-      issueId: input.issueId
-    });
-    const comment = await commentPayload.comment;
-    if (!comment) {
-      throw new Error("Failed to create comment");
-    }
-    this.logActivity("create_comment", "comment", comment.id, {
-      issueId: input.issueId,
-      bodyLength: input.body.length,
-      accountId: state.accountId
-    }, true);
-    return comment;
-  }
-  async updateComment(commentId, body, accountId) {
-    const state = this.getAccountState(accountId);
-    const commentPayload = await state.client.updateComment(commentId, {
-      body
-    });
-    const comment = await commentPayload.comment;
-    if (!comment) {
-      throw new Error("Failed to update comment");
-    }
-    this.logActivity("update_comment", "comment", commentId, { bodyLength: body.length, accountId: state.accountId }, true);
-    return comment;
-  }
-  async deleteComment(commentId, accountId) {
-    const state = this.getAccountState(accountId);
-    const payload = await state.client.deleteComment(commentId);
-    if (!payload.success) {
-      throw new Error("Failed to delete comment");
-    }
-    this.logActivity("delete_comment", "comment", commentId, { accountId: state.accountId }, true);
-  }
-  async listComments(issueId, limit = 25, accountId) {
-    const issue = await this.getClient(accountId).issue(issueId);
-    const connection = await issue.comments({ first: Math.min(limit, 100) });
-    return connection.nodes;
-  }
-  async getProjects(teamId, accountId) {
-    const state = this.getAccountState(accountId);
-    const query = state.client.projects({
-      first: 100
-    });
-    const projects = await query;
-    let projectList = await projects.nodes;
-    if (teamId) {
-      const filteredProjects = await Promise.all(projectList.map(async (project) => {
-        const projectTeams = await project.teams();
-        const teamsList = await projectTeams.nodes;
-        const hasTeam = teamsList.some((team) => team.id === teamId);
-        return hasTeam ? project : null;
-      }));
-      projectList = filteredProjects.filter(Boolean);
-    }
-    this.logActivity("list_projects", "project", "all", {
-      count: projectList.length,
-      teamId,
-      accountId: state.accountId
-    }, true);
-    return projectList;
-  }
-  async getProject(projectId, accountId) {
-    const state = this.getAccountState(accountId);
-    const project = await state.client.project(projectId);
-    this.logActivity("get_project", "project", projectId, {
-      name: project.name,
-      accountId: state.accountId
-    }, true);
-    return project;
-  }
-  async getUsers(accountId) {
-    const state = this.getAccountState(accountId);
-    const users = await state.client.users();
-    const userList = await users.nodes;
-    this.logActivity("list_users", "user", "all", {
-      count: userList.length,
-      accountId: state.accountId
-    }, true);
-    return userList;
-  }
-  async getCurrentUser(accountId) {
-    const state = this.getAccountState(accountId);
-    const user = await state.client.viewer;
-    this.logActivity("get_current_user", "user", user.id, {
-      email: user.email,
-      name: user.name,
-      accountId: state.accountId
-    }, true);
-    return user;
-  }
-  async getUserTeams(accountId) {
-    const state = this.getAccountState(accountId);
-    const viewer = await state.client.viewer;
-    const teams = await viewer.teams();
-    const teamList = await teams.nodes;
-    this.logActivity("list_user_teams", "team", viewer.id, {
-      count: teamList.length,
-      accountId: state.accountId
-    }, true);
-    return teamList;
-  }
-  async getLabels(teamId, accountId) {
-    const state = this.getAccountState(accountId);
-    const query = state.client.issueLabels({
-      first: 100,
-      filter: teamId ? {
-        team: { id: { eq: teamId } }
-      } : undefined
-    });
-    const labels = await query;
-    const labelList = await labels.nodes;
-    this.logActivity("list_labels", "label", "all", {
-      count: labelList.length,
-      teamId,
-      accountId: state.accountId
-    }, true);
-    return labelList;
-  }
-  async getWorkflowStates(teamId, accountId) {
-    const state = this.getAccountState(accountId);
-    const states = await state.client.workflowStates({
-      filter: {
-        team: { id: { eq: teamId } }
-      }
-    });
-    const stateList = await states.nodes;
-    this.logActivity("list_workflow_states", "team", teamId, {
-      count: stateList.length,
-      accountId: state.accountId
-    }, true);
-    return stateList;
-  }
-}
-
-// src/index.ts
-var linearPlugin = {
-  name: "@elizaos/plugin-linear-ts",
-  description: "Plugin for integrating with Linear issue tracking system",
-  services: [LinearService],
-  actions: [...promoteSubactionsToActions(linearAction)],
-  providers: [
-    linearIssuesProvider,
-    linearTeamsProvider,
-    linearProjectsProvider,
-    linearActivityProvider
-  ],
-  init: async (_config, runtime) => {
-    registerLinearSearchCategory(runtime);
-    try {
-      const manager = getConnectorAccountManager(runtime);
-      manager.registerProvider(createLinearConnectorAccountProvider(runtime));
-    } catch (err) {
-      logger14.warn({
-        src: "plugin:linear",
-        err: err instanceof Error ? err.message : String(err)
-      }, "Failed to register Linear provider with ConnectorAccountManager");
-    }
-  }
-};
-export {
-  resolveLinearDefaultAccount,
-  resolveLinearAccountId,
-  resolveLinearAccount,
-  readLinearAccounts,
-  normalizeLinearAccountId,
-  linearPlugin,
-  hasLinearAccountConfig,
-  createLinearConnectorAccountProvider,
-  LinearService,
-  DEFAULT_LINEAR_ACCOUNT_ROLE,
-  DEFAULT_LINEAR_ACCOUNT_ID
-};
-
-//# debugId=F5689DC5E2BC1C6664756E2164756E21