@elizaos/plugin-bluesky 2.0.0-alpha.6 → 2.0.0-beta.1

package/dist/node/index.node.js

@@ -1,16 +1,12 @@
 // index.ts
-import { logger as logger4 } from "@elizaos/core";
-
-// services/bluesky.ts
-import { logger as logger3, Service } from "@elizaos/core";
-
-// client.ts
-import { BskyAgent, RichText } from "@atproto/api";
-import { logger } from "@elizaos/core";
-import { LRUCache } from "lru-cache";
+import {
+  getConnectorAccountManager,
+  logger as logger4
+} from "@elizaos/core";
 
 // types/index.ts
-import { z } from "zod";
+import * as zod from "zod";
+var z2 = zod.z ?? zod;
 var BLUESKY_SERVICE_URL = "https://bsky.social";
 var BLUESKY_MAX_POST_LENGTH = 300;
 var BLUESKY_POLL_INTERVAL = 60;
@@ -35,20 +31,20 @@ var CACHE_SIZE = {
   NOTIFICATIONS: 1000,
   CONVERSATIONS: 100
 };
-var BlueSkyConfigSchema = z.object({
-  handle: z.string().regex(AT_PROTOCOL_HANDLE_REGEX, "Invalid handle format"),
-  password: z.string().min(1),
-  service: z.string().url().default(BLUESKY_SERVICE_URL),
-  dryRun: z.boolean().default(false),
-  pollInterval: z.number().positive().default(BLUESKY_POLL_INTERVAL),
-  enablePost: z.boolean().default(true),
-  postIntervalMin: z.number().positive().default(BLUESKY_POST_INTERVAL_MIN),
-  postIntervalMax: z.number().positive().default(BLUESKY_POST_INTERVAL_MAX),
-  enableActionProcessing: z.boolean().default(true),
-  actionInterval: z.number().positive().default(BLUESKY_ACTION_INTERVAL),
-  postImmediately: z.boolean().default(false),
-  maxActionsProcessing: z.number().positive().default(BLUESKY_MAX_ACTIONS),
-  enableDMs: z.boolean().default(true)
+var BlueSkyConfigSchema = z2.object({
+  handle: z2.string().regex(AT_PROTOCOL_HANDLE_REGEX, "Invalid handle format"),
+  password: z2.string().min(1),
+  service: z2.string().url().default(BLUESKY_SERVICE_URL),
+  dryRun: z2.boolean().default(false),
+  pollInterval: z2.number().positive().default(BLUESKY_POLL_INTERVAL),
+  enablePost: z2.boolean().default(true),
+  postIntervalMin: z2.number().positive().default(BLUESKY_POST_INTERVAL_MIN),
+  postIntervalMax: z2.number().positive().default(BLUESKY_POST_INTERVAL_MAX),
+  enableActionProcessing: z2.boolean().default(true),
+  actionInterval: z2.number().positive().default(BLUESKY_ACTION_INTERVAL),
+  postImmediately: z2.boolean().default(false),
+  maxActionsProcessing: z2.number().positive().default(BLUESKY_MAX_ACTIONS),
+  enableDMs: z2.boolean().default(true)
 });
 
 class BlueSkyError extends Error {
@@ -62,7 +58,254 @@ class BlueSkyError extends Error {
   }
 }
 
+// utils/config.ts
+var DEFAULT_BLUESKY_ACCOUNT_ID = "default";
+function getApiKeyOptional(runtime, key) {
+  const value = runtime.getSetting(key);
+  return typeof value === "string" ? value : undefined;
+}
+function stringSetting(runtime, key) {
+  const value = runtime.getSetting(key);
+  return typeof value === "string" && value.trim() ? value.trim() : undefined;
+}
+function characterConfig(runtime) {
+  const settings = runtime.character?.settings;
+  const raw = settings?.bluesky;
+  return raw && typeof raw === "object" ? raw : {};
+}
+function parseAccountsJson(runtime) {
+  const raw = stringSetting(runtime, "BLUESKY_ACCOUNTS");
+  if (!raw)
+    return {};
+  try {
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) {
+      return Object.fromEntries(parsed.filter((item) => Boolean(item) && typeof item === "object").map((item) => [
+        normalizeBlueSkyAccountId(item.accountId ?? item.id),
+        item
+      ]));
+    }
+    return parsed && typeof parsed === "object" ? parsed : {};
+  } catch {
+    return {};
+  }
+}
+function allAccountConfigs(runtime) {
+  return {
+    ...characterConfig(runtime).accounts ?? {},
+    ...parseAccountsJson(runtime)
+  };
+}
+function accountConfig(runtime, accountId) {
+  const accounts = allAccountConfigs(runtime);
+  return accounts[accountId] ?? accounts[normalizeBlueSkyAccountId(accountId)] ?? {};
+}
+function readRawField(record, keys) {
+  if (!record)
+    return;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+    if (typeof value === "number" || typeof value === "boolean")
+      return String(value);
+  }
+  return;
+}
+function boolValue(value, fallback = false) {
+  if (typeof value === "boolean")
+    return value;
+  if (typeof value === "string")
+    return value.trim().toLowerCase() === "true";
+  return fallback;
+}
+function intValue(value, fallback) {
+  const parsed = Number.parseInt(String(value ?? ""), 10);
+  return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+}
+function normalizeBlueSkyAccountId(accountId) {
+  if (typeof accountId !== "string")
+    return DEFAULT_BLUESKY_ACCOUNT_ID;
+  const trimmed = accountId.trim();
+  return trimmed || DEFAULT_BLUESKY_ACCOUNT_ID;
+}
+function listBlueSkyAccountIds(runtime) {
+  const ids = new Set;
+  const config = characterConfig(runtime);
+  if (stringSetting(runtime, "BLUESKY_HANDLE") || config.handle && config.password) {
+    ids.add(DEFAULT_BLUESKY_ACCOUNT_ID);
+  }
+  for (const id of Object.keys(allAccountConfigs(runtime))) {
+    ids.add(normalizeBlueSkyAccountId(id));
+  }
+  return Array.from(ids.size ? ids : new Set([DEFAULT_BLUESKY_ACCOUNT_ID])).sort((a, b) => a.localeCompare(b));
+}
+function resolveDefaultBlueSkyAccountId(runtime) {
+  const requested = stringSetting(runtime, "BLUESKY_DEFAULT_ACCOUNT_ID") ?? stringSetting(runtime, "BLUESKY_ACCOUNT_ID");
+  if (requested)
+    return normalizeBlueSkyAccountId(requested);
+  const ids = listBlueSkyAccountIds(runtime);
+  return ids.includes(DEFAULT_BLUESKY_ACCOUNT_ID) ? DEFAULT_BLUESKY_ACCOUNT_ID : ids[0] ?? DEFAULT_BLUESKY_ACCOUNT_ID;
+}
+function readBlueSkyAccountId(...sources) {
+  for (const source of sources) {
+    if (!source || typeof source !== "object")
+      continue;
+    const record = source;
+    const parameters = record.parameters && typeof record.parameters === "object" ? record.parameters : {};
+    const data = record.data && typeof record.data === "object" ? record.data : {};
+    const metadata = record.metadata && typeof record.metadata === "object" ? record.metadata : {};
+    const bluesky = data.bluesky && typeof data.bluesky === "object" ? data.bluesky : {};
+    const value = record.accountId ?? parameters.accountId ?? data.accountId ?? bluesky.accountId ?? metadata.accountId;
+    if (typeof value === "string" && value.trim())
+      return normalizeBlueSkyAccountId(value);
+  }
+  return;
+}
+function hasBlueSkyEnabled(runtime, accountId) {
+  const normalizedAccountId = normalizeBlueSkyAccountId(accountId ?? resolveDefaultBlueSkyAccountId(runtime));
+  const base = characterConfig(runtime);
+  const account = accountConfig(runtime, normalizedAccountId);
+  const allowEnv = normalizedAccountId === DEFAULT_BLUESKY_ACCOUNT_ID;
+  const enabled = readRawField(account, ["enabled", "BLUESKY_ENABLED"]) ?? readRawField(base, ["enabled", "BLUESKY_ENABLED"]) ?? (allowEnv ? runtime.getSetting("BLUESKY_ENABLED") : undefined);
+  if (enabled)
+    return String(enabled).toLowerCase() === "true";
+  return Boolean((readRawField(account, ["handle", "BLUESKY_HANDLE"]) ?? readRawField(base, ["handle", "BLUESKY_HANDLE"]) ?? (allowEnv ? stringSetting(runtime, "BLUESKY_HANDLE") : undefined)) && (readRawField(account, ["password", "BLUESKY_PASSWORD"]) ?? readRawField(base, ["password", "BLUESKY_PASSWORD"]) ?? (allowEnv ? stringSetting(runtime, "BLUESKY_PASSWORD") : undefined)));
+}
+function validateBlueSkyConfig(runtime, accountId) {
+  const normalizedAccountId = normalizeBlueSkyAccountId(accountId ?? resolveDefaultBlueSkyAccountId(runtime));
+  const base = characterConfig(runtime);
+  const account = accountConfig(runtime, normalizedAccountId);
+  const allowEnv = normalizedAccountId === DEFAULT_BLUESKY_ACCOUNT_ID;
+  const result = BlueSkyConfigSchema.safeParse({
+    handle: readRawField(account, ["handle", "BLUESKY_HANDLE"]) ?? readRawField(base, ["handle", "BLUESKY_HANDLE"]) ?? (allowEnv ? stringSetting(runtime, "BLUESKY_HANDLE") : undefined) ?? "",
+    password: readRawField(account, ["password", "BLUESKY_PASSWORD"]) ?? readRawField(base, ["password", "BLUESKY_PASSWORD"]) ?? (allowEnv ? stringSetting(runtime, "BLUESKY_PASSWORD") : undefined) ?? "",
+    service: readRawField(account, ["service", "BLUESKY_SERVICE"]) ?? readRawField(base, ["service", "BLUESKY_SERVICE"]) ?? (allowEnv ? stringSetting(runtime, "BLUESKY_SERVICE") : undefined) ?? BLUESKY_SERVICE_URL,
+    dryRun: boolValue(readRawField(account, ["dryRun", "BLUESKY_DRY_RUN"]) ?? readRawField(base, ["dryRun", "BLUESKY_DRY_RUN"]) ?? (allowEnv ? runtime.getSetting("BLUESKY_DRY_RUN") : undefined)),
+    pollInterval: intValue(readRawField(account, ["pollInterval", "BLUESKY_POLL_INTERVAL"]) ?? readRawField(base, ["pollInterval", "BLUESKY_POLL_INTERVAL"]) ?? (allowEnv ? runtime.getSetting("BLUESKY_POLL_INTERVAL") : undefined), BLUESKY_POLL_INTERVAL),
+    enablePost: String(readRawField(account, ["enablePost", "BLUESKY_ENABLE_POSTING"]) ?? readRawField(base, ["enablePost", "BLUESKY_ENABLE_POSTING"]) ?? (allowEnv ? runtime.getSetting("BLUESKY_ENABLE_POSTING") : undefined) ?? "true").toLowerCase() !== "false",
+    postIntervalMin: intValue(readRawField(account, ["postIntervalMin", "BLUESKY_POST_INTERVAL_MIN"]) ?? readRawField(base, ["postIntervalMin", "BLUESKY_POST_INTERVAL_MIN"]) ?? (allowEnv ? runtime.getSetting("BLUESKY_POST_INTERVAL_MIN") : undefined), BLUESKY_POST_INTERVAL_MIN),
+    postIntervalMax: intValue(readRawField(account, ["postIntervalMax", "BLUESKY_POST_INTERVAL_MAX"]) ?? readRawField(base, ["postIntervalMax", "BLUESKY_POST_INTERVAL_MAX"]) ?? (allowEnv ? runtime.getSetting("BLUESKY_POST_INTERVAL_MAX") : undefined), BLUESKY_POST_INTERVAL_MAX),
+    enableActionProcessing: String(readRawField(account, [
+      "enableActionProcessing",
+      "BLUESKY_ENABLE_ACTION_PROCESSING"
+    ]) ?? readRawField(base, [
+      "enableActionProcessing",
+      "BLUESKY_ENABLE_ACTION_PROCESSING"
+    ]) ?? (allowEnv ? runtime.getSetting("BLUESKY_ENABLE_ACTION_PROCESSING") : undefined) ?? "true").toLowerCase() !== "false",
+    actionInterval: intValue(readRawField(account, ["actionInterval", "BLUESKY_ACTION_INTERVAL"]) ?? readRawField(base, ["actionInterval", "BLUESKY_ACTION_INTERVAL"]) ?? (allowEnv ? runtime.getSetting("BLUESKY_ACTION_INTERVAL") : undefined), BLUESKY_ACTION_INTERVAL),
+    postImmediately: boolValue(readRawField(account, ["postImmediately", "BLUESKY_POST_IMMEDIATELY"]) ?? readRawField(base, ["postImmediately", "BLUESKY_POST_IMMEDIATELY"]) ?? (allowEnv ? runtime.getSetting("BLUESKY_POST_IMMEDIATELY") : undefined)),
+    maxActionsProcessing: intValue(readRawField(account, [
+      "maxActionsProcessing",
+      "BLUESKY_MAX_ACTIONS_PROCESSING"
+    ]) ?? readRawField(base, [
+      "maxActionsProcessing",
+      "BLUESKY_MAX_ACTIONS_PROCESSING"
+    ]) ?? (allowEnv ? runtime.getSetting("BLUESKY_MAX_ACTIONS_PROCESSING") : undefined), BLUESKY_MAX_ACTIONS),
+    enableDMs: String(readRawField(account, ["enableDMs", "BLUESKY_ENABLE_DMS"]) ?? readRawField(base, ["enableDMs", "BLUESKY_ENABLE_DMS"]) ?? (allowEnv ? runtime.getSetting("BLUESKY_ENABLE_DMS") : undefined) ?? "true").toLowerCase() !== "false"
+  });
+  if (!result.success) {
+    const errors = result.error.errors?.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ") || result.error.toString();
+    throw new Error(`Invalid BlueSky configuration: ${errors}`);
+  }
+  return { ...result.data, accountId: normalizedAccountId };
+}
+function getPollInterval(runtime, accountId) {
+  const config = validateBlueSkyConfig(runtime, accountId);
+  return config.pollInterval * 1000;
+}
+function getActionInterval(runtime, accountId) {
+  const config = validateBlueSkyConfig(runtime, accountId);
+  return config.actionInterval * 1000;
+}
+function getMaxActionsProcessing(runtime, accountId) {
+  const config = validateBlueSkyConfig(runtime, accountId);
+  return config.maxActionsProcessing;
+}
+function isPostingEnabled(runtime, accountId) {
+  const config = validateBlueSkyConfig(runtime, accountId);
+  return config.enablePost;
+}
+function shouldPostImmediately(runtime, accountId) {
+  const config = validateBlueSkyConfig(runtime, accountId);
+  return config.postImmediately;
+}
+function getPostIntervalRange(runtime, accountId) {
+  const config = validateBlueSkyConfig(runtime, accountId);
+  return {
+    min: config.postIntervalMin * 1000,
+    max: config.postIntervalMax * 1000
+  };
+}
+
+// connector-account-provider.ts
+var BLUESKY_PROVIDER_ID = "bluesky";
+function toConnectorAccount(runtime, accountId) {
+  let connected = false;
+  let handle = "";
+  let service = "";
+  try {
+    const config = validateBlueSkyConfig(runtime, accountId);
+    connected = Boolean(config.handle && config.password);
+    handle = config.handle;
+    service = config.service;
+  } catch {
+    connected = false;
+  }
+  const now = Date.now();
+  return {
+    id: accountId,
+    provider: BLUESKY_PROVIDER_ID,
+    label: handle || accountId,
+    role: "OWNER",
+    purpose: ["posting", "reading"],
+    accessGate: "open",
+    status: connected ? "connected" : "disabled",
+    externalId: handle || undefined,
+    displayHandle: handle || undefined,
+    createdAt: now,
+    updatedAt: now,
+    metadata: {
+      service
+    }
+  };
+}
+function createBlueSkyConnectorAccountProvider(runtime) {
+  return {
+    provider: BLUESKY_PROVIDER_ID,
+    label: "BlueSky",
+    listAccounts: async (_manager) => {
+      const ids = listBlueSkyAccountIds(runtime);
+      return ids.map((id) => toConnectorAccount(runtime, id));
+    },
+    createAccount: async (input, _manager) => {
+      return {
+        ...input,
+        provider: BLUESKY_PROVIDER_ID,
+        role: input.role ?? "OWNER",
+        purpose: input.purpose ?? ["posting", "reading"],
+        accessGate: input.accessGate ?? "open",
+        status: input.status ?? "pending"
+      };
+    },
+    patchAccount: async (_accountId, patch, _manager) => {
+      return { ...patch, provider: BLUESKY_PROVIDER_ID };
+    },
+    deleteAccount: async (_accountId, _manager) => {}
+  };
+}
+
+// services/bluesky.ts
+import {
+  ChannelType as ChannelType3,
+  logger as logger3,
+  Service
+} from "@elizaos/core";
+
 // client.ts
+import { BskyAgent, RichText } from "@atproto/api";
+import { logger } from "@elizaos/core";
+import { LRUCache } from "lru-cache";
 function isPostView(item) {
   return typeof item === "object" && item !== null && "uri" in item && "cid" in item && "author" in item && "record" in item && "indexedAt" in item && typeof item.uri === "string" && typeof item.cid === "string";
 }
@@ -180,6 +423,18 @@ class BlueSkyClient {
       })
     };
   }
+  async searchPosts(params) {
+    const api = this.agent;
+    const response = await api.app.bsky.feed.searchPosts({
+      q: params.query,
+      limit: params.limit ?? 25,
+      cursor: params.cursor
+    });
+    return {
+      posts: response.data.posts.map(adaptPostView),
+      cursor: response.data.cursor
+    };
+  }
   async sendPost(request) {
     if (this.config.dryRun) {
       logger.info(`Dry run: would create post with text: ${request.content.text}`);
@@ -199,7 +454,20 @@ class BlueSkyClient {
     if (request.content.embed) {
       record.embed = request.content.embed;
     }
+    logger.info({
+      src: "plugin:bluesky",
+      op: "atproto:post",
+      textLength: rt.text.length,
+      hasReply: Boolean(request.replyTo),
+      hasEmbed: Boolean(request.content.embed)
+    }, "Publishing Bluesky post via atproto");
     const response = await this.agent.post(record);
+    logger.info({
+      src: "plugin:bluesky",
+      op: "atproto:post",
+      uri: response.uri,
+      cid: response.cid
+    }, "Bluesky post published");
     const thread = await this.agent.getPostThread({
       uri: response.uri,
       depth: 0
@@ -295,65 +563,15 @@ class BlueSkyClient {
 }
 
 // managers/agent.ts
-import { logger as logger2 } from "@elizaos/core";
-
-// utils/config.ts
-function getApiKeyOptional(runtime, key) {
-  const value = runtime.getSetting(key);
-  return typeof value === "string" ? value : undefined;
-}
-function hasBlueSkyEnabled(runtime) {
-  const enabled = runtime.getSetting("BLUESKY_ENABLED");
-  if (enabled)
-    return String(enabled).toLowerCase() === "true";
-  return Boolean(runtime.getSetting("BLUESKY_HANDLE") && runtime.getSetting("BLUESKY_PASSWORD"));
-}
-function validateBlueSkyConfig(runtime) {
-  const result = BlueSkyConfigSchema.safeParse({
-    handle: String(runtime.getSetting("BLUESKY_HANDLE") ?? ""),
-    password: String(runtime.getSetting("BLUESKY_PASSWORD") ?? ""),
-    service: String(runtime.getSetting("BLUESKY_SERVICE") ?? BLUESKY_SERVICE_URL),
-    dryRun: runtime.getSetting("BLUESKY_DRY_RUN") === "true",
-    pollInterval: parseInt(String(runtime.getSetting("BLUESKY_POLL_INTERVAL") ?? ""), 10) || BLUESKY_POLL_INTERVAL,
-    enablePost: runtime.getSetting("BLUESKY_ENABLE_POSTING") !== "false",
-    postIntervalMin: parseInt(String(runtime.getSetting("BLUESKY_POST_INTERVAL_MIN") ?? ""), 10) || BLUESKY_POST_INTERVAL_MIN,
-    postIntervalMax: parseInt(String(runtime.getSetting("BLUESKY_POST_INTERVAL_MAX") ?? ""), 10) || BLUESKY_POST_INTERVAL_MAX,
-    enableActionProcessing: runtime.getSetting("BLUESKY_ENABLE_ACTION_PROCESSING") !== "false",
-    actionInterval: parseInt(String(runtime.getSetting("BLUESKY_ACTION_INTERVAL") ?? ""), 10) || BLUESKY_ACTION_INTERVAL,
-    postImmediately: runtime.getSetting("BLUESKY_POST_IMMEDIATELY") === "true",
-    maxActionsProcessing: parseInt(String(runtime.getSetting("BLUESKY_MAX_ACTIONS_PROCESSING") ?? ""), 10) || BLUESKY_MAX_ACTIONS,
-    enableDMs: runtime.getSetting("BLUESKY_ENABLE_DMS") !== "false"
-  });
-  if (!result.success) {
-    const errors = result.error.errors?.map((e) => `${e.path.join(".")}: ${e.message}`).join(", ") || result.error.toString();
-    throw new Error(`Invalid BlueSky configuration: ${errors}`);
-  }
-  return result.data;
-}
-function getPollInterval(runtime) {
-  const seconds = parseInt(String(runtime.getSetting("BLUESKY_POLL_INTERVAL") ?? ""), 10) || BLUESKY_POLL_INTERVAL;
-  return seconds * 1000;
-}
-function getActionInterval(runtime) {
-  const seconds = parseInt(String(runtime.getSetting("BLUESKY_ACTION_INTERVAL") ?? ""), 10) || BLUESKY_ACTION_INTERVAL;
-  return seconds * 1000;
-}
-function getMaxActionsProcessing(runtime) {
-  return parseInt(String(runtime.getSetting("BLUESKY_MAX_ACTIONS_PROCESSING") ?? ""), 10) || BLUESKY_MAX_ACTIONS;
-}
-function isPostingEnabled(runtime) {
-  return runtime.getSetting("BLUESKY_ENABLE_POSTING") !== "false";
-}
-function shouldPostImmediately(runtime) {
-  return runtime.getSetting("BLUESKY_POST_IMMEDIATELY") === "true";
-}
-function getPostIntervalRange(runtime) {
-  const min = parseInt(String(runtime.getSetting("BLUESKY_POST_INTERVAL_MIN") ?? ""), 10) || BLUESKY_POST_INTERVAL_MIN;
-  const max = parseInt(String(runtime.getSetting("BLUESKY_POST_INTERVAL_MAX") ?? ""), 10) || BLUESKY_POST_INTERVAL_MAX;
-  return { min: min * 1000, max: max * 1000 };
+import {
+  logger as logger2,
+  setTrajectoryPurpose,
+  withStandaloneTrajectory
+} from "@elizaos/core";
+function cursorCacheKey(agentId, accountId) {
+  return `bluesky:cursor:${agentId}:${accountId}`;
 }
 
-// managers/agent.ts
 class BlueSkyAgentManager {
   runtime;
   config;
@@ -363,24 +581,33 @@ class BlueSkyAgentManager {
   postTimer = null;
   running = false;
   lastSeenAt = null;
+  accountId;
   constructor(runtime, config, client) {
     this.runtime = runtime;
     this.config = config;
     this.client = client;
+    this.accountId = normalizeBlueSkyAccountId(config.accountId ?? DEFAULT_BLUESKY_ACCOUNT_ID);
+  }
+  getAccountId() {
+    return this.accountId;
   }
   async start() {
     if (this.running)
       return;
     await this.client.authenticate();
     this.running = true;
+    const cached = await this.runtime.getCache(cursorCacheKey(this.runtime.agentId, this.accountId));
+    if (typeof cached === "string" && cached) {
+      this.lastSeenAt = cached;
+    }
     this.startNotificationPolling();
     if (this.config.enableActionProcessing) {
       this.startActionProcessing();
     }
-    if (isPostingEnabled(this.runtime)) {
+    if (isPostingEnabled(this.runtime, this.accountId)) {
       this.startAutomatedPosting();
     }
-    logger2.success({ agentId: this.runtime.agentId }, "BlueSky agent manager started");
+    logger2.success({ agentId: this.runtime.agentId, accountId: this.accountId }, "BlueSky agent manager started");
   }
   async stop() {
     this.running = false;
@@ -394,10 +621,10 @@ class BlueSkyAgentManager {
     this.actionTimer = null;
     this.postTimer = null;
     await this.client.cleanup();
-    logger2.info({ agentId: this.runtime.agentId }, "BlueSky agent manager stopped");
+    logger2.info({ agentId: this.runtime.agentId, accountId: this.accountId }, "BlueSky agent manager stopped");
   }
   startNotificationPolling() {
-    const interval = getPollInterval(this.runtime);
+    const interval = getPollInterval(this.runtime, this.accountId);
     this.pollNotifications();
     this.pollTimer = setInterval(() => this.pollNotifications(), interval);
   }
@@ -413,6 +640,7 @@ class BlueSkyAgentManager {
     }) : notifications;
     if (newNotifications.length > 0) {
       this.lastSeenAt = notifications[0].indexedAt;
+      await this.runtime.setCache(cursorCacheKey(this.runtime.agentId, this.accountId), this.lastSeenAt);
       for (const notification of newNotifications) {
         this.emitNotificationEvent(notification);
       }
@@ -433,26 +661,28 @@ class BlueSkyAgentManager {
       const payload = {
         runtime: this.runtime,
         source: "bluesky",
+        accountId: this.accountId,
         notification
       };
       this.runtime.emitEvent(event, payload);
     }
   }
   startActionProcessing() {
-    const interval = getActionInterval(this.runtime);
-    this.processActions();
-    this.actionTimer = setInterval(() => this.processActions(), interval);
+    const interval = getActionInterval(this.runtime, this.accountId);
+    this.processQueuedActions();
+    this.actionTimer = setInterval(() => this.processQueuedActions(), interval);
   }
-  async processActions() {
+  async processQueuedActions() {
     if (!this.running)
       return;
-    const max = getMaxActionsProcessing(this.runtime);
+    const max = getMaxActionsProcessing(this.runtime, this.accountId);
     const { notifications } = await this.client.getNotifications(max);
     for (const notification of notifications) {
       if (notification.reason === "mention" || notification.reason === "reply") {
         const payload = {
           runtime: this.runtime,
           source: "bluesky",
+          accountId: this.accountId,
           notification
         };
         this.runtime.emitEvent("bluesky.should_respond", payload);
@@ -460,47 +690,93 @@ class BlueSkyAgentManager {
     }
   }
   startAutomatedPosting() {
-    if (shouldPostImmediately(this.runtime)) {
+    if (shouldPostImmediately(this.runtime, this.accountId)) {
       this.createAutomatedPost();
     }
     this.scheduleNextPost();
   }
   scheduleNextPost() {
-    const { min, max } = getPostIntervalRange(this.runtime);
+    const { min, max } = getPostIntervalRange(this.runtime, this.accountId);
     const interval = Math.random() * (max - min) + min;
     this.postTimer = setTimeout(() => {
       if (this.running) {
-        this.createAutomatedPost();
-        this.scheduleNextPost();
+        this.createAutomatedPost().finally(() => this.scheduleNextPost());
       }
     }, interval);
   }
-  createAutomatedPost() {
-    const payload = {
-      runtime: this.runtime,
-      source: "bluesky",
-      automated: true
-    };
-    this.runtime.emitEvent("bluesky.create_post", payload);
+  async createAutomatedPost() {
+    await withStandaloneTrajectory(this.runtime, {
+      source: "plugin-bluesky:auto-post",
+      metadata: {
+        platform: "bluesky",
+        kind: "public_post_generation",
+        automated: true,
+        accountId: this.accountId
+      }
+    }, async () => {
+      setTrajectoryPurpose("background");
+      const payload = {
+        runtime: this.runtime,
+        source: "bluesky",
+        automated: true,
+        accountId: this.accountId
+      };
+      await this.runtime.emitEvent("bluesky.create_post", payload);
+    });
   }
 }
 
 // services/message.ts
-import { composePrompt, ModelType } from "@elizaos/core";
+import {
+  ChannelType,
+  composePrompt,
+  createUniqueUuid,
+  ModelType
+} from "@elizaos/core";
 
-// generated/prompts/typescript/prompts.ts
+// prompts.ts
 var generateDmTemplate = `Generate a friendly direct message response under 200 characters.`;
 var generatePostTemplate = `Generate an engaging BlueSky post under {{maxLength}} characters.`;
 var truncatePostTemplate = `Shorten to under {{maxLength}} characters: "{{text}}"`;
 
 // services/message.ts
+var BLUESKY_CONNECTOR_CONTEXTS = ["social", "connectors"];
+function normalizeBlueSkyQuery(value) {
+  return value.trim().replace(/^@/, "").toLowerCase();
+}
+function scoreBlueSkyMatch(query, id, labels) {
+  if (!query)
+    return 0.45;
+  if (id.toLowerCase() === query)
+    return 1;
+  let bestScore = 0;
+  for (const label of labels) {
+    const normalized = label?.trim().replace(/^@/, "").toLowerCase();
+    if (!normalized)
+      continue;
+    if (normalized === query) {
+      bestScore = Math.max(bestScore, 0.95);
+    } else if (normalized.startsWith(query)) {
+      bestScore = Math.max(bestScore, 0.85);
+    } else if (normalized.includes(query)) {
+      bestScore = Math.max(bestScore, 0.7);
+    }
+  }
+  return bestScore;
+}
+
 class BlueSkyMessageService {
   client;
   runtime;
+  accountId;
   static serviceType = "IMessageService";
-  constructor(client, runtime) {
+  constructor(client, runtime, accountId = "default") {
     this.client = client;
     this.runtime = runtime;
+    this.accountId = accountId;
+  }
+  getAccountId() {
+    return normalizeBlueSkyAccountId(this.accountId);
   }
   async getMessages(convoId, limit = 50) {
     const response = await this.client.getMessages(convoId, limit);
@@ -514,6 +790,215 @@ class BlueSkyMessageService {
     const response = await this.client.getConversations(limit);
     return response.conversations;
   }
+  async handleSendMessage(runtime, target, content) {
+    const requestedAccountId = normalizeBlueSkyAccountId(target.accountId ?? readBlueSkyAccountId(content, target) ?? this.getAccountId());
+    if (requestedAccountId !== this.getAccountId()) {
+      throw new Error(`BlueSky account '${requestedAccountId}' is not available in this service instance`);
+    }
+    const text = typeof content.text === "string" ? content.text.trim() : "";
+    if (!text) {
+      throw new Error("BlueSky DM connector requires non-empty text content.");
+    }
+    let convoId = target.channelId ?? target.threadId;
+    if (!convoId && target.roomId) {
+      const room = await runtime.getRoom(target.roomId);
+      convoId = room?.channelId;
+    }
+    if (!convoId) {
+      throw new Error("BlueSky DM connector requires a conversation target.");
+    }
+    await this.sendMessage(convoId, text);
+  }
+  async fetchConnectorMessages(context, params = {}) {
+    const requestedAccountId = normalizeBlueSkyAccountId(context.accountId ?? context.metadata?.accountId ?? this.getAccountId());
+    if (requestedAccountId !== this.getAccountId()) {
+      throw new Error(`BlueSky account '${requestedAccountId}' is not available in this service instance`);
+    }
+    const target = params.target ?? context.target;
+    let convoId = target?.channelId ?? target?.threadId;
+    if (!convoId && target?.roomId) {
+      const room = await context.runtime.getRoom(target.roomId);
+      convoId = room?.channelId;
+    }
+    if (convoId) {
+      const messages = await this.getMessages(convoId, clampLimit(params.limit, 25, 100));
+      return messages.map((message) => this.messageToMemory(context.runtime, message, convoId));
+    }
+    const conversations = await this.getConversations(clampLimit(params.limit, 25, 50));
+    const memories = [];
+    for (const conversation of conversations) {
+      const messages = await this.getMessages(conversation.id, 1);
+      memories.push(...messages.map((message) => this.messageToMemory(context.runtime, message, conversation.id)));
+    }
+    return memories.sort((a, b) => (b.createdAt ?? 0) - (a.createdAt ?? 0));
+  }
+  async resolveConnectorTargets(query, _context) {
+    const normalizedQuery = normalizeBlueSkyQuery(query);
+    const conversations = await this.getConversations(50);
+    return conversations.map((conversation) => {
+      const score = scoreBlueSkyMatch(normalizedQuery, conversation.id, [
+        ...conversation.members.flatMap((member) => [
+          member.handle,
+          member.displayName,
+          member.did
+        ])
+      ]);
+      return score > 0 ? this.buildConversationTarget(conversation, score) : null;
+    }).filter((target) => Boolean(target)).slice(0, 25);
+  }
+  async listConnectorRooms(_context) {
+    const conversations = await this.getConversations(50);
+    return conversations.map((conversation) => this.buildConversationTarget(conversation, 0.5));
+  }
+  async listRecentConnectorTargets(context) {
+    const targets = [];
+    const room = context.roomId && typeof context.runtime.getRoom === "function" ? await context.runtime.getRoom(context.roomId) : null;
+    const convoId = context.target?.channelId ?? room?.channelId;
+    if (convoId) {
+      targets.push({
+        target: {
+          source: "bluesky",
+          accountId: this.getAccountId(),
+          channelId: convoId
+        },
+        label: `BlueSky conversation ${convoId}`,
+        kind: "thread",
+        score: 0.95,
+        contexts: [...BLUESKY_CONNECTOR_CONTEXTS],
+        metadata: { accountId: this.getAccountId(), blueskyConvoId: convoId }
+      });
+    }
+    targets.push(...await this.listConnectorRooms(context));
+    const seen = new Set;
+    return targets.filter((target) => {
+      const channelId = target.target.channelId;
+      if (!channelId || seen.has(channelId))
+        return false;
+      seen.add(channelId);
+      return true;
+    }).slice(0, 25);
+  }
+  async getConnectorChatContext(target, context) {
+    let convoId = target.channelId ?? target.threadId;
+    if (!convoId && target.roomId) {
+      const room = await context.runtime.getRoom(target.roomId);
+      convoId = room?.channelId;
+    }
+    if (!convoId)
+      return null;
+    const messages = await this.getMessages(convoId, 25);
+    return {
+      target: {
+        source: "bluesky",
+        accountId: this.getAccountId(),
+        channelId: convoId
+      },
+      label: `BlueSky conversation ${convoId}`,
+      recentMessages: messages.map((message) => ({
+        name: message.sender.did,
+        text: message.text ?? "",
+        timestamp: Date.parse(message.sentAt),
+        metadata: {
+          accountId: this.getAccountId(),
+          blueskyMessageId: message.id,
+          blueskySenderDid: message.sender.did
+        }
+      })),
+      metadata: { accountId: this.getAccountId(), blueskyConvoId: convoId }
+    };
+  }
+  async getConnectorUserContext(entityId, _context) {
+    const normalizedEntity = entityId.trim().replace(/^@/, "");
+    if (!normalizedEntity)
+      return null;
+    const conversations = await this.getConversations(50);
+    for (const conversation of conversations) {
+      const member = conversation.members.find((candidate) => candidate.did === entityId || candidate.handle === normalizedEntity || candidate.displayName === entityId);
+      if (!member)
+        continue;
+      return {
+        entityId,
+        label: member.displayName || member.handle || member.did,
+        aliases: [member.handle, member.displayName, member.did].filter((value) => Boolean(value)),
+        handles: {
+          bluesky: member.handle ?? member.did
+        },
+        metadata: {
+          accountId: this.getAccountId(),
+          blueskyDid: member.did,
+          blueskyHandle: member.handle,
+          avatar: member.avatar
+        }
+      };
+    }
+    return null;
+  }
+  buildConversationTarget(conversation, score) {
+    const sessionDid = this.client.getSession()?.did;
+    const otherMembers = conversation.members.filter((member) => member.did !== sessionDid);
+    const label = otherMembers.map((member) => member.displayName || member.handle || member.did).filter(Boolean).join(", ") || `BlueSky conversation ${conversation.id}`;
+    return {
+      target: {
+        source: "bluesky",
+        accountId: this.getAccountId(),
+        channelId: conversation.id
+      },
+      label,
+      kind: "thread",
+      description: "BlueSky direct message conversation",
+      score,
+      contexts: [...BLUESKY_CONNECTOR_CONTEXTS],
+      metadata: {
+        accountId: this.getAccountId(),
+        blueskyConvoId: conversation.id,
+        unreadCount: conversation.unreadCount,
+        muted: conversation.muted,
+        members: conversation.members.map((member) => ({
+          did: member.did,
+          handle: member.handle,
+          displayName: member.displayName
+        }))
+      }
+    };
+  }
+  messageToMemory(runtime, message, convoId) {
+    const senderDid = message.sender.did || "unknown";
+    const createdAt = Date.parse(message.sentAt) || Date.now();
+    const entityId = senderDid === runtime.agentId ? runtime.agentId : createUniqueUuid(runtime, `bluesky:user:${senderDid}`);
+    const roomId = createUniqueUuid(runtime, `bluesky:dm:${convoId}`);
+    return {
+      id: createUniqueUuid(runtime, `bluesky:dm:${message.id}`),
+      agentId: runtime.agentId,
+      entityId,
+      roomId,
+      createdAt,
+      content: {
+        text: message.text ?? "",
+        source: "bluesky",
+        channelType: ChannelType.DM
+      },
+      metadata: {
+        type: "message",
+        source: "bluesky",
+        accountId: this.getAccountId(),
+        provider: "bluesky",
+        timestamp: createdAt,
+        fromBot: entityId === runtime.agentId,
+        messageIdFull: message.id,
+        chatType: ChannelType.DM,
+        sender: {
+          id: senderDid
+        },
+        bluesky: {
+          accountId: this.getAccountId(),
+          messageId: message.id,
+          convoId,
+          rev: message.rev,
+          senderDid
+        }
+      }
+    };
+  }
   async generateReply() {
     const prompt = composePrompt({
       state: {},
@@ -526,16 +1011,46 @@ class BlueSkyMessageService {
     return response;
   }
 }
+function clampLimit(value, fallback, max) {
+  if (!Number.isFinite(value))
+    return fallback;
+  return Math.min(Math.max(1, Math.floor(value)), max);
+}
 
 // services/post.ts
-import { composePrompt as composePrompt2, ModelType as ModelType2 } from "@elizaos/core";
+import {
+  ChannelType as ChannelType2,
+  composePrompt as composePrompt2,
+  createUniqueUuid as createUniqueUuid2,
+  ModelType as ModelType2
+} from "@elizaos/core";
+function clampLimit2(value, fallback, max) {
+  if (!Number.isFinite(value))
+    return fallback;
+  return Math.min(Math.max(1, Math.floor(value)), max);
+}
+function readContentString(content, keys) {
+  const record = content;
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" && value.trim())
+      return value.trim();
+  }
+  return;
+}
+
 class BlueSkyPostService {
   client;
   runtime;
+  accountId;
   static serviceType = "IPostService";
-  constructor(client, runtime) {
+  constructor(client, runtime, accountId = "default") {
     this.client = client;
     this.runtime = runtime;
+    this.accountId = accountId;
+  }
+  getAccountId() {
+    return normalizeBlueSkyAccountId(this.accountId);
   }
   async getPosts(limit = 50, cursor) {
     const response = await this.client.getTimeline({ limit, cursor });
@@ -552,9 +1067,91 @@ class BlueSkyPostService {
     };
     return this.client.sendPost(request);
   }
+  async handleSendPost(runtime, content) {
+    const requestedAccountId = normalizeBlueSkyAccountId(readBlueSkyAccountId(content) ?? this.getAccountId());
+    if (requestedAccountId !== this.getAccountId()) {
+      throw new Error(`BlueSky account '${requestedAccountId}' is not available in this service instance`);
+    }
+    const replyUri = readContentString(content, ["replyToUri", "replyTo"]);
+    const replyCid = readContentString(content, ["replyToCid"]);
+    const post = await this.createPost(content.text ?? "", replyUri && replyCid ? { uri: replyUri, cid: replyCid } : undefined);
+    return this.postToMemory(runtime, post);
+  }
+  async fetchFeed(context, params = {}) {
+    const requestedAccountId = normalizeBlueSkyAccountId(context.accountId ?? context.metadata?.accountId ?? this.getAccountId());
+    if (requestedAccountId !== this.getAccountId()) {
+      throw new Error(`BlueSky account '${requestedAccountId}' is not available in this service instance`);
+    }
+    const response = await this.client.getTimeline({
+      limit: clampLimit2(params.limit, 25, 100),
+      cursor: params.cursor
+    });
+    return response.feed.map((item) => this.postToMemory(context.runtime, item.post));
+  }
+  async searchPosts(context, params) {
+    const requestedAccountId = normalizeBlueSkyAccountId(context.accountId ?? context.metadata?.accountId ?? this.getAccountId());
+    if (requestedAccountId !== this.getAccountId()) {
+      throw new Error(`BlueSky account '${requestedAccountId}' is not available in this service instance`);
+    }
+    const query = params.query?.trim();
+    if (!query) {
+      throw new Error("BlueSky searchPosts connector requires a query.");
+    }
+    const response = await this.client.searchPosts({
+      query,
+      limit: clampLimit2(params.limit, 25, 100),
+      cursor: params.cursor
+    });
+    return response.posts.map((post) => this.postToMemory(context.runtime, post));
+  }
   async deletePost(uri) {
     await this.client.deletePost(uri);
   }
+  postToMemory(runtime, post) {
+    const createdAt = Date.parse(post.indexedAt || post.record.createdAt) || Date.now();
+    const authorId = post.author.did || post.author.handle || "unknown";
+    const entityId = authorId === runtime.agentId ? runtime.agentId : createUniqueUuid2(runtime, `bluesky:user:${authorId}`);
+    const roomId = createUniqueUuid2(runtime, `bluesky:feed:${authorId}`);
+    return {
+      id: createUniqueUuid2(runtime, `bluesky:post:${post.uri}`),
+      agentId: runtime.agentId,
+      entityId,
+      roomId,
+      createdAt,
+      content: {
+        text: post.record.text,
+        source: "bluesky",
+        url: `https://bsky.app/profile/${post.author.handle}/post/${post.uri.split("/").pop()}`,
+        channelType: ChannelType2.FEED
+      },
+      metadata: {
+        type: "message",
+        source: "bluesky",
+        accountId: this.getAccountId(),
+        provider: "bluesky",
+        timestamp: createdAt,
+        fromBot: entityId === runtime.agentId,
+        messageIdFull: post.uri,
+        chatType: ChannelType2.FEED,
+        sender: {
+          id: authorId,
+          name: post.author.displayName,
+          username: post.author.handle
+        },
+        bluesky: {
+          accountId: this.getAccountId(),
+          uri: post.uri,
+          cid: post.cid,
+          authorDid: post.author.did,
+          authorHandle: post.author.handle,
+          replyCount: post.replyCount,
+          repostCount: post.repostCount,
+          likeCount: post.likeCount,
+          quoteCount: post.quoteCount
+        }
+      }
+    };
+  }
   async generateContent() {
     const prompt = composePrompt2({
       state: {
@@ -588,9 +1185,7 @@ class BlueSkyPostService {
 // services/bluesky.ts
 class BlueSkyService extends Service {
   static instance;
-  managers = new Map;
-  messageServices = new Map;
-  postServices = new Map;
+  agents = new Map;
   static serviceType = BLUESKY_SERVICE_NAME;
   capabilityDescription = "Send and receive messages on BlueSky";
   static getInstance() {
@@ -599,48 +1194,230 @@ class BlueSkyService extends Service {
   }
   static async start(runtime) {
     const service = BlueSkyService.getInstance();
-    if (service.managers.has(runtime.agentId)) {
+    if (service.agents.has(runtime.agentId)) {
       return service;
     }
     if (!hasBlueSkyEnabled(runtime)) {
       return service;
     }
-    const config = validateBlueSkyConfig(runtime);
-    const client = new BlueSkyClient({
-      service: config.service,
-      handle: config.handle,
-      password: config.password,
-      dryRun: config.dryRun
-    });
-    const manager = new BlueSkyAgentManager(runtime, config, client);
-    service.managers.set(runtime.agentId, manager);
-    service.messageServices.set(runtime.agentId, new BlueSkyMessageService(client, runtime));
-    service.postServices.set(runtime.agentId, new BlueSkyPostService(client, runtime));
-    await manager.start();
-    logger3.success({ agentId: runtime.agentId }, "BlueSky client started");
+    const accountIds = listBlueSkyAccountIds(runtime);
+    const defaultAccountId = normalizeBlueSkyAccountId(resolveDefaultBlueSkyAccountId(runtime));
+    const accounts = {
+      defaultAccountId,
+      managers: new Map,
+      messageServices: new Map,
+      postServices: new Map
+    };
+    service.agents.set(runtime.agentId, accounts);
+    for (const accountId of accountIds) {
+      if (!hasBlueSkyEnabled(runtime, accountId)) {
+        continue;
+      }
+      const config = validateBlueSkyConfig(runtime, accountId);
+      if (!config.handle || !config.password) {
+        logger3.warn({ agentId: runtime.agentId, accountId }, "Skipping BlueSky account without handle/password");
+        continue;
+      }
+      const client = new BlueSkyClient({
+        service: config.service,
+        handle: config.handle,
+        password: config.password,
+        dryRun: config.dryRun
+      });
+      const manager = new BlueSkyAgentManager(runtime, config, client);
+      accounts.managers.set(accountId, manager);
+      accounts.messageServices.set(accountId, new BlueSkyMessageService(client, runtime, accountId));
+      accounts.postServices.set(accountId, new BlueSkyPostService(client, runtime, accountId));
+      await manager.start();
+      logger3.success({ agentId: runtime.agentId, accountId }, "BlueSky client started");
+    }
     return service;
   }
   static async stop(runtime) {
     const service = BlueSkyService.getInstance();
-    const manager = service.managers.get(runtime.agentId);
-    if (!manager)
+    const accounts = service.agents.get(runtime.agentId);
+    if (!accounts)
       return;
-    await manager.stop();
-    service.managers.delete(runtime.agentId);
-    service.messageServices.delete(runtime.agentId);
-    service.postServices.delete(runtime.agentId);
+    for (const manager of accounts.managers.values()) {
+      await manager.stop();
+    }
+    service.agents.delete(runtime.agentId);
     logger3.info({ agentId: runtime.agentId }, "BlueSky client stopped");
   }
+  static registerSendHandlers(runtime, serviceInstance) {
+    const accounts = serviceInstance?.agents.get(runtime.agentId);
+    if (!accounts) {
+      runtime.logger.warn({ src: "plugin:bluesky", agentId: runtime.agentId }, "Cannot register BlueSky connectors; service is not initialized");
+      return;
+    }
+    for (const postService of accounts.postServices.values()) {
+      BlueSkyService.registerPostConnector(runtime, postService);
+    }
+    if (typeof runtime.registerMessageConnector === "function" && accounts.messageServices.size > 0) {
+      for (const messageService2 of accounts.messageServices.values()) {
+        BlueSkyService.registerMessageConnector(runtime, messageService2);
+      }
+      return;
+    }
+    const defaultAccountId = normalizeBlueSkyAccountId(accounts.defaultAccountId);
+    const messageService = accounts.messageServices.get(defaultAccountId);
+    if (!messageService) {
+      runtime.logger.warn({ src: "plugin:bluesky", agentId: runtime.agentId }, "Cannot register legacy BlueSky DM send handler; default message service is not initialized");
+      return;
+    }
+    runtime.registerSendHandler("bluesky", messageService.handleSendMessage.bind(messageService));
+  }
+  static registerMessageConnector(runtime, messageService) {
+    const accountId = messageService.getAccountId();
+    const registration = {
+      source: "bluesky",
+      accountId,
+      label: "BlueSky",
+      description: "BlueSky DM connector for sending private messages to conversations.",
+      capabilities: [
+        "send_message",
+        "fetch_messages",
+        "resolve_targets",
+        "list_rooms",
+        "chat_context",
+        "user_context"
+      ],
+      supportedTargetKinds: ["thread", "user"],
+      contexts: ["social", "connectors"],
+      metadata: {
+        accountId,
+        service: BLUESKY_SERVICE_NAME
+      },
+      resolveTargets: messageService.resolveConnectorTargets.bind(messageService),
+      listRecentTargets: messageService.listRecentConnectorTargets.bind(messageService),
+      listRooms: messageService.listConnectorRooms.bind(messageService),
+      getChatContext: messageService.getConnectorChatContext.bind(messageService),
+      getUserContext: messageService.getConnectorUserContext.bind(messageService),
+      fetchMessages: messageService.fetchConnectorMessages.bind(messageService),
+      contentShaping: {
+        systemPromptFragment: "For BlueSky DMs, keep messages direct and conversational. Avoid public-feed conventions like hashtags unless the user asked.",
+        constraints: {
+          supportsMarkdown: false,
+          channelType: ChannelType3.DM
+        }
+      },
+      sendHandler: messageService.handleSendMessage.bind(messageService)
+    };
+    runtime.registerMessageConnector(registration);
+    runtime.logger.info({ src: "plugin:bluesky", agentId: runtime.agentId, accountId }, "Registered BlueSky DM connector");
+  }
+  static registerPostConnector(runtime, postService) {
+    const withPostConnector = runtime;
+    if (typeof withPostConnector.registerPostConnector !== "function") {
+      return;
+    }
+    const accountId = postService.getAccountId?.() ?? DEFAULT_BLUESKY_ACCOUNT_ID;
+    withPostConnector.registerPostConnector({
+      source: "bluesky",
+      accountId,
+      label: "BlueSky",
+      description: "BlueSky public feed connector for publishing posts, reading the timeline, and searching posts.",
+      capabilities: ["post", "fetch_feed", "search_posts"],
+      contexts: ["social", "social_posting", "connectors"],
+      metadata: {
+        accountId,
+        service: BLUESKY_SERVICE_NAME
+      },
+      postHandler: postService.handleSendPost.bind(postService),
+      fetchFeed: postService.fetchFeed.bind(postService),
+      searchPosts: postService.searchPosts.bind(postService),
+      contentShaping: {
+        systemPromptFragment: "For BlueSky posts, write a public post under 300 characters. Handles, links, and facets are supported by the connector; do not exceed the platform limit.",
+        constraints: {
+          maxLength: 300,
+          supportsMarkdown: false,
+          channelType: ChannelType3.FEED
+        }
+      }
+    });
+    runtime.logger.info({ src: "plugin:bluesky", agentId: runtime.agentId, accountId }, "Registered BlueSky post connector");
+  }
   async stop() {
-    for (const manager of this.managers.values()) {
-      await BlueSkyService.stop(manager.runtime);
+    for (const [agentId, accounts] of this.agents) {
+      for (const manager of accounts.managers.values()) {
+        await manager.stop();
+      }
+      this.agents.delete(agentId);
     }
   }
-  getMessageService(agentId) {
-    return this.messageServices.get(agentId);
+  getMessageServiceForAccount(accountId, agentId) {
+    const resolvedAgentId = agentId ?? this.firstAgentId();
+    if (!resolvedAgentId)
+      return;
+    const accounts = this.agents.get(resolvedAgentId);
+    if (!accounts)
+      return;
+    const id = accountId ? normalizeBlueSkyAccountId(accountId) : accounts.defaultAccountId;
+    return accounts.messageServices.get(id);
+  }
+  getPostServiceForAccount(accountId, agentId) {
+    const resolvedAgentId = agentId ?? this.firstAgentId();
+    if (!resolvedAgentId)
+      return;
+    const accounts = this.agents.get(resolvedAgentId);
+    if (!accounts)
+      return;
+    const id = accountId ? normalizeBlueSkyAccountId(accountId) : accounts.defaultAccountId;
+    return accounts.postServices.get(id);
+  }
+  getMessageService(agentId, accountId) {
+    return this.getMessageServiceForAccount(accountId, agentId);
+  }
+  getPostService(agentId, accountId) {
+    return this.getPostServiceForAccount(accountId, agentId);
+  }
+  getDefaultAccountId(agentId) {
+    const resolvedAgentId = agentId ?? this.firstAgentId();
+    return resolvedAgentId ? this.agents.get(resolvedAgentId)?.defaultAccountId : undefined;
   }
-  getPostService(agentId) {
-    return this.postServices.get(agentId);
+  listAccountIds(agentId) {
+    const resolvedAgentId = agentId ?? this.firstAgentId();
+    const accounts = resolvedAgentId ? this.agents.get(resolvedAgentId) : undefined;
+    return accounts ? Array.from(accounts.managers.keys()) : [];
+  }
+  firstAgentId() {
+    return this.agents.keys().next().value;
+  }
+}
+
+// workflow-credential-provider.ts
+import { Service as Service2 } from "@elizaos/core";
+var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
+var SUPPORTED = ["httpHeaderAuth"];
+
+class BlueskyWorkflowCredentialProvider extends Service2 {
+  static serviceType = WORKFLOW_CREDENTIAL_PROVIDER_TYPE;
+  capabilityDescription = "Supplies Bluesky credentials to the workflow plugin.";
+  static async start(runtime) {
+    return new BlueskyWorkflowCredentialProvider(runtime);
+  }
+  async stop() {}
+  async resolve(_userId, credType) {
+    if (credType !== "httpHeaderAuth")
+      return null;
+    const handle = this.runtime.getSetting("BLUESKY_HANDLE");
+    const password = this.runtime.getSetting("BLUESKY_PASSWORD");
+    if (!handle?.trim() || !password?.trim())
+      return null;
+    return {
+      status: "credential_data",
+      data: {
+        name: "X-Bluesky-Handle",
+        value: handle.trim(),
+        appPassword: password.trim()
+      }
+    };
+  }
+  checkCredentialTypes(credTypes) {
+    return {
+      supported: credTypes.filter((t) => SUPPORTED.includes(t)),
+      unsupported: credTypes.filter((t) => !SUPPORTED.includes(t))
+    };
   }
 }
 
@@ -696,20 +1473,38 @@ var blueSkyPlugin = {
     BLUESKY_ACTION_INTERVAL: process.env.BLUESKY_ACTION_INTERVAL ?? null,
     BLUESKY_POST_IMMEDIATELY: process.env.BLUESKY_POST_IMMEDIATELY ?? null,
     BLUESKY_MAX_ACTIONS_PROCESSING: process.env.BLUESKY_MAX_ACTIONS_PROCESSING ?? null,
-    BLUESKY_MAX_POST_LENGTH: process.env.BLUESKY_MAX_POST_LENGTH ?? null
+    BLUESKY_MAX_POST_LENGTH: process.env.BLUESKY_MAX_POST_LENGTH ?? null,
+    BLUESKY_ACCOUNTS: process.env.BLUESKY_ACCOUNTS ?? null,
+    BLUESKY_DEFAULT_ACCOUNT_ID: process.env.BLUESKY_DEFAULT_ACCOUNT_ID ?? null
   },
-  async init(_config, _runtime) {
+  async init(_config, runtime) {
+    try {
+      const manager = getConnectorAccountManager(runtime);
+      manager.registerProvider(createBlueSkyConnectorAccountProvider(runtime));
+    } catch (err) {
+      logger4.warn({
+        src: "plugin:bluesky",
+        err: err instanceof Error ? err.message : String(err)
+      }, "Failed to register BlueSky provider with ConnectorAccountManager");
+    }
     logger4.log("BlueSky plugin initialized");
   },
-  services: [BlueSkyService],
+  actions: [],
+  services: [BlueSkyService, BlueskyWorkflowCredentialProvider],
   tests: pluginTests
 };
-var typescript_default = blueSkyPlugin;
 export {
-  typescript_default as default,
+  resolveDefaultBlueSkyAccountId,
+  readBlueSkyAccountId,
+  normalizeBlueSkyAccountId,
+  listBlueSkyAccountIds,
+  default2 as default,
+  createBlueSkyConnectorAccountProvider,
   blueSkyPlugin,
+  DEFAULT_BLUESKY_ACCOUNT_ID,
   BlueSkyService,
-  BlueSkyClient
+  BlueSkyClient,
+  BLUESKY_PROVIDER_ID
 };
 
-//# debugId=8E1C17CA465481F364756E2164756E21
+//# debugId=ABC5C845CC8C11C664756E2164756E21