@elizaos/plugin-bluesky 2.0.0-beta.1 → 2.0.11-beta.7

package/dist/cjs/index.node.cjs

@@ -1,1555 +0,0 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-function __accessProp(key) {
-  return this[key];
-}
-var __toESMCache_node;
-var __toESMCache_esm;
-var __toESM = (mod, isNodeMode, target) => {
-  var canCache = mod != null && typeof mod === "object";
-  if (canCache) {
-    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
-    var cached = cache.get(mod);
-    if (cached)
-      return cached;
-  }
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: __accessProp.bind(mod, key),
-        enumerable: true
-      });
-  if (canCache)
-    cache.set(mod, to);
-  return to;
-};
-var __toCommonJS = (from) => {
-  var entry = (__moduleCache ??= new WeakMap).get(from), desc;
-  if (entry)
-    return entry;
-  entry = __defProp({}, "__esModule", { value: true });
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (var key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(entry, key))
-        __defProp(entry, key, {
-          get: __accessProp.bind(from, key),
-          enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
-        });
-  }
-  __moduleCache.set(from, entry);
-  return entry;
-};
-var __moduleCache;
-var __returnValue = (v) => v;
-function __exportSetter(name, newValue) {
-  this[name] = __returnValue.bind(null, newValue);
-}
-var __export = (target, all) => {
-  for (var name in all)
-    __defProp(target, name, {
-      get: all[name],
-      enumerable: true,
-      configurable: true,
-      set: __exportSetter.bind(all, name)
-    });
-};
-
-// index.node.ts
-var exports_index_node = {};
-__export(exports_index_node, {
-  resolveDefaultBlueSkyAccountId: () => resolveDefaultBlueSkyAccountId,
-  readBlueSkyAccountId: () => readBlueSkyAccountId,
-  normalizeBlueSkyAccountId: () => normalizeBlueSkyAccountId,
-  listBlueSkyAccountIds: () => listBlueSkyAccountIds,
-  default: () => import__.default,
-  createBlueSkyConnectorAccountProvider: () => createBlueSkyConnectorAccountProvider,
-  blueSkyPlugin: () => blueSkyPlugin,
-  DEFAULT_BLUESKY_ACCOUNT_ID: () => DEFAULT_BLUESKY_ACCOUNT_ID,
-  BlueSkyService: () => BlueSkyService,
-  BlueSkyClient: () => BlueSkyClient,
-  BLUESKY_PROVIDER_ID: () => BLUESKY_PROVIDER_ID
-});
-module.exports = __toCommonJS(exports_index_node);
-
-// index.ts
-var import_core7 = require("@elizaos/core");
-
-// types/index.ts
-var zod = __toESM(require("zod"));
-var z2 = zod.z ?? zod;
-var BLUESKY_SERVICE_URL = "https://bsky.social";
-var BLUESKY_MAX_POST_LENGTH = 300;
-var BLUESKY_POLL_INTERVAL = 60;
-var BLUESKY_POST_INTERVAL_MIN = 1800;
-var BLUESKY_POST_INTERVAL_MAX = 3600;
-var BLUESKY_ACTION_INTERVAL = 120;
-var BLUESKY_MAX_ACTIONS = 5;
-var BLUESKY_CHAT_SERVICE_DID = "did:web:api.bsky.chat";
-var BLUESKY_SERVICE_NAME = "bluesky";
-var AT_PROTOCOL_HANDLE_REGEX = /^([a-zA-Z0-9]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]([a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?$/;
-var CACHE_TTL = {
-  PROFILE: 3600000,
-  TIMELINE: 300000,
-  POST: 1800000,
-  NOTIFICATIONS: 300000,
-  CONVERSATIONS: 300000
-};
-var CACHE_SIZE = {
-  PROFILE: 1000,
-  TIMELINE: 500,
-  POST: 1e4,
-  NOTIFICATIONS: 1000,
-  CONVERSATIONS: 100
-};
-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 {
-  code;
-  status;
-  constructor(message, code, status) {
-    super(message);
-    this.code = code;
-    this.status = status;
-    this.name = "BlueSkyError";
-  }
-}
-
-// 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
-var import_core5 = require("@elizaos/core");
-
-// client.ts
-var import_api = require("@atproto/api");
-var import_core = require("@elizaos/core");
-var import_lru_cache = require("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";
-}
-function isReplyWithPostViews(reply) {
-  return typeof reply === "object" && reply !== null && "root" in reply && "parent" in reply && isPostView(reply.root) && isPostView(reply.parent);
-}
-function adaptPostView(postView) {
-  const author = postView.author;
-  const record = postView.record;
-  return {
-    uri: postView.uri,
-    cid: postView.cid,
-    author: {
-      did: author.did,
-      handle: author.handle,
-      displayName: author.displayName,
-      description: author.description,
-      avatar: author.avatar,
-      banner: author.banner,
-      followersCount: author.followersCount,
-      followsCount: author.followsCount,
-      postsCount: author.postsCount,
-      indexedAt: author.indexedAt,
-      createdAt: author.createdAt
-    },
-    record: {
-      $type: record.$type ?? "app.bsky.feed.post",
-      text: record.text ?? "",
-      facets: record.facets,
-      embed: record.embed,
-      createdAt: record.createdAt ?? ""
-    },
-    embed: postView.embed,
-    replyCount: postView.replyCount,
-    repostCount: postView.repostCount,
-    likeCount: postView.likeCount,
-    quoteCount: postView.quoteCount,
-    indexedAt: postView.indexedAt
-  };
-}
-
-class BlueSkyClient {
-  config;
-  agent;
-  session = null;
-  profileCache;
-  constructor(config) {
-    this.config = config;
-    this.agent = new import_api.BskyAgent({ service: config.service });
-    this.profileCache = new import_lru_cache.LRUCache({
-      max: CACHE_SIZE.PROFILE,
-      ttl: CACHE_TTL.PROFILE
-    });
-  }
-  async authenticate() {
-    const response = await this.agent.login({
-      identifier: this.config.handle,
-      password: this.config.password
-    });
-    if (!response.success) {
-      throw new BlueSkyError("Authentication failed", "AUTH_FAILED");
-    }
-    this.session = {
-      did: response.data.did,
-      handle: response.data.handle,
-      email: response.data.email,
-      accessJwt: response.data.accessJwt,
-      refreshJwt: response.data.refreshJwt
-    };
-    import_core.logger.info(`Authenticated with BlueSky: ${this.session.handle}`);
-    return this.session;
-  }
-  getSession() {
-    return this.session;
-  }
-  async getProfile(handle) {
-    const cached = this.profileCache.get(handle);
-    if (cached)
-      return cached;
-    const response = await this.agent.getProfile({ actor: handle });
-    const profile = {
-      did: response.data.did,
-      handle: response.data.handle,
-      displayName: response.data.displayName,
-      description: response.data.description,
-      avatar: response.data.avatar,
-      banner: response.data.banner,
-      followersCount: response.data.followersCount,
-      followsCount: response.data.followsCount,
-      postsCount: response.data.postsCount,
-      indexedAt: response.data.indexedAt,
-      createdAt: response.data.createdAt
-    };
-    this.profileCache.set(handle, profile);
-    return profile;
-  }
-  async getTimeline(params = {}) {
-    const response = await this.agent.getTimeline({
-      algorithm: params.algorithm,
-      limit: params.limit ?? 50,
-      cursor: params.cursor
-    });
-    return {
-      cursor: response.data.cursor,
-      feed: response.data.feed.map((item) => {
-        const reply = isReplyWithPostViews(item.reply) ? {
-          root: adaptPostView(item.reply.root),
-          parent: adaptPostView(item.reply.parent)
-        } : undefined;
-        return {
-          post: adaptPostView(item.post),
-          reply,
-          reason: item.reason
-        };
-      })
-    };
-  }
-  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) {
-      import_core.logger.info(`Dry run: would create post with text: ${request.content.text}`);
-      return this.mockPost(request.content.text);
-    }
-    const rt = new import_api.RichText({ text: request.content.text });
-    await rt.detectFacets(this.agent);
-    const record = {
-      $type: "app.bsky.feed.post",
-      text: rt.text,
-      facets: rt.facets,
-      createdAt: new Date().toISOString()
-    };
-    if (request.replyTo) {
-      record.reply = { root: request.replyTo, parent: request.replyTo };
-    }
-    if (request.content.embed) {
-      record.embed = request.content.embed;
-    }
-    import_core.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);
-    import_core.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
-    });
-    if (thread.data.thread.$type !== "app.bsky.feed.defs#threadViewPost") {
-      throw new BlueSkyError("Failed to retrieve created post", "POST_CREATE_FAILED");
-    }
-    const threadViewPost = thread.data.thread;
-    return adaptPostView(threadViewPost.post);
-  }
-  async deletePost(uri) {
-    if (this.config.dryRun) {
-      import_core.logger.info(`Dry run: would delete post: ${uri}`);
-      return;
-    }
-    await this.agent.deletePost(uri);
-  }
-  async likePost(uri, cid) {
-    if (this.config.dryRun) {
-      import_core.logger.info(`Dry run: would like post: ${uri}`);
-      return;
-    }
-    await this.agent.like(uri, cid);
-  }
-  async repost(uri, cid) {
-    if (this.config.dryRun) {
-      import_core.logger.info({ uri }, "Dry run: would repost");
-      return;
-    }
-    await this.agent.repost(uri, cid);
-  }
-  async getNotifications(limit = 50, cursor) {
-    const response = await this.agent.listNotifications({ limit, cursor });
-    return {
-      notifications: response.data.notifications,
-      cursor: response.data.cursor
-    };
-  }
-  async updateSeenNotifications() {
-    await this.agent.updateSeenNotifications();
-  }
-  async getConversations(limit = 50, cursor) {
-    const response = await this.agent.api.chat.bsky.convo.listConvos({ limit, cursor }, { headers: { "atproto-proxy": BLUESKY_CHAT_SERVICE_DID } });
-    return {
-      conversations: response.data.convos,
-      cursor: response.data.cursor
-    };
-  }
-  async getMessages(convoId, limit = 50, cursor) {
-    const response = await this.agent.api.chat.bsky.convo.getMessages({ convoId, limit, cursor }, { headers: { "atproto-proxy": BLUESKY_CHAT_SERVICE_DID } });
-    return {
-      messages: response.data.messages,
-      cursor: response.data.cursor
-    };
-  }
-  async sendMessage(request) {
-    if (this.config.dryRun) {
-      import_core.logger.info({ convoId: request.convoId }, "Dry run: would send message");
-      return this.mockMessage(request.message.text ?? "");
-    }
-    const response = await this.agent.api.chat.bsky.convo.sendMessage({
-      convoId: request.convoId,
-      message: { text: request.message.text ?? "" }
-    }, { headers: { "atproto-proxy": BLUESKY_CHAT_SERVICE_DID } });
-    return response.data;
-  }
-  async cleanup() {
-    this.profileCache.clear();
-    this.session = null;
-  }
-  mockPost(text) {
-    const now = new Date().toISOString();
-    return {
-      uri: `mock://post/${Date.now()}`,
-      cid: `mock-cid-${Date.now()}`,
-      author: {
-        did: this.session?.did ?? "did:plc:mock",
-        handle: this.session?.handle ?? "mock.handle"
-      },
-      record: { $type: "app.bsky.feed.post", text, createdAt: now },
-      indexedAt: now
-    };
-  }
-  mockMessage(text) {
-    return {
-      id: `mock-msg-${Date.now()}`,
-      rev: "1",
-      text,
-      sender: { did: this.session?.did ?? "did:plc:mock" },
-      sentAt: new Date().toISOString()
-    };
-  }
-}
-
-// managers/agent.ts
-var import_core2 = require("@elizaos/core");
-function cursorCacheKey(agentId, accountId) {
-  return `bluesky:cursor:${agentId}:${accountId}`;
-}
-
-class BlueSkyAgentManager {
-  runtime;
-  config;
-  client;
-  pollTimer = null;
-  actionTimer = null;
-  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, this.accountId)) {
-      this.startAutomatedPosting();
-    }
-    import_core2.logger.success({ agentId: this.runtime.agentId, accountId: this.accountId }, "BlueSky agent manager started");
-  }
-  async stop() {
-    this.running = false;
-    if (this.pollTimer)
-      clearInterval(this.pollTimer);
-    if (this.actionTimer)
-      clearInterval(this.actionTimer);
-    if (this.postTimer)
-      clearTimeout(this.postTimer);
-    this.pollTimer = null;
-    this.actionTimer = null;
-    this.postTimer = null;
-    await this.client.cleanup();
-    import_core2.logger.info({ agentId: this.runtime.agentId, accountId: this.accountId }, "BlueSky agent manager stopped");
-  }
-  startNotificationPolling() {
-    const interval = getPollInterval(this.runtime, this.accountId);
-    this.pollNotifications();
-    this.pollTimer = setInterval(() => this.pollNotifications(), interval);
-  }
-  async pollNotifications() {
-    if (!this.running)
-      return;
-    const { notifications } = await this.client.getNotifications(50);
-    if (notifications.length === 0)
-      return;
-    const newNotifications = this.lastSeenAt ? notifications.filter((n) => {
-      const lastSeen = this.lastSeenAt;
-      return lastSeen !== null && n.indexedAt > lastSeen;
-    }) : 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);
-      }
-      await this.client.updateSeenNotifications();
-    }
-  }
-  emitNotificationEvent(notification) {
-    const eventMap = {
-      mention: "bluesky.mention_received",
-      reply: "bluesky.mention_received",
-      follow: "bluesky.follow_received",
-      like: "bluesky.like_received",
-      repost: "bluesky.repost_received",
-      quote: "bluesky.quote_received"
-    };
-    const event = eventMap[notification.reason];
-    if (event) {
-      const payload = {
-        runtime: this.runtime,
-        source: "bluesky",
-        accountId: this.accountId,
-        notification
-      };
-      this.runtime.emitEvent(event, payload);
-    }
-  }
-  startActionProcessing() {
-    const interval = getActionInterval(this.runtime, this.accountId);
-    this.processQueuedActions();
-    this.actionTimer = setInterval(() => this.processQueuedActions(), interval);
-  }
-  async processQueuedActions() {
-    if (!this.running)
-      return;
-    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);
-      }
-    }
-  }
-  startAutomatedPosting() {
-    if (shouldPostImmediately(this.runtime, this.accountId)) {
-      this.createAutomatedPost();
-    }
-    this.scheduleNextPost();
-  }
-  scheduleNextPost() {
-    const { min, max } = getPostIntervalRange(this.runtime, this.accountId);
-    const interval = Math.random() * (max - min) + min;
-    this.postTimer = setTimeout(() => {
-      if (this.running) {
-        this.createAutomatedPost().finally(() => this.scheduleNextPost());
-      }
-    }, interval);
-  }
-  async createAutomatedPost() {
-    await import_core2.withStandaloneTrajectory(this.runtime, {
-      source: "plugin-bluesky:auto-post",
-      metadata: {
-        platform: "bluesky",
-        kind: "public_post_generation",
-        automated: true,
-        accountId: this.accountId
-      }
-    }, async () => {
-      import_core2.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
-var import_core3 = require("@elizaos/core");
-
-// 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, 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);
-    return response.messages;
-  }
-  async sendMessage(convoId, text) {
-    const messageText = text.trim() || await this.generateReply();
-    return this.client.sendMessage({ convoId, message: { text: messageText } });
-  }
-  async getConversations(limit = 50) {
-    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 : import_core3.createUniqueUuid(runtime, `bluesky:user:${senderDid}`);
-    const roomId = import_core3.createUniqueUuid(runtime, `bluesky:dm:${convoId}`);
-    return {
-      id: import_core3.createUniqueUuid(runtime, `bluesky:dm:${message.id}`),
-      agentId: runtime.agentId,
-      entityId,
-      roomId,
-      createdAt,
-      content: {
-        text: message.text ?? "",
-        source: "bluesky",
-        channelType: import_core3.ChannelType.DM
-      },
-      metadata: {
-        type: "message",
-        source: "bluesky",
-        accountId: this.getAccountId(),
-        provider: "bluesky",
-        timestamp: createdAt,
-        fromBot: entityId === runtime.agentId,
-        messageIdFull: message.id,
-        chatType: import_core3.ChannelType.DM,
-        sender: {
-          id: senderDid
-        },
-        bluesky: {
-          accountId: this.getAccountId(),
-          messageId: message.id,
-          convoId,
-          rev: message.rev,
-          senderDid
-        }
-      }
-    };
-  }
-  async generateReply() {
-    const prompt = import_core3.composePrompt({
-      state: {},
-      template: generateDmTemplate
-    });
-    const response = await this.runtime.useModel(import_core3.ModelType.TEXT_SMALL, {
-      prompt,
-      maxTokens: 50
-    });
-    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
-var import_core4 = require("@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, 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 });
-    return response.feed.map((item) => item.post);
-  }
-  async createPost(text, replyTo) {
-    let postText = text.trim() || await this.generateContent();
-    if (postText.length > BLUESKY_MAX_POST_LENGTH) {
-      postText = await this.truncate(postText);
-    }
-    const request = {
-      content: { text: postText },
-      replyTo
-    };
-    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 : import_core4.createUniqueUuid(runtime, `bluesky:user:${authorId}`);
-    const roomId = import_core4.createUniqueUuid(runtime, `bluesky:feed:${authorId}`);
-    return {
-      id: import_core4.createUniqueUuid(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: import_core4.ChannelType.FEED
-      },
-      metadata: {
-        type: "message",
-        source: "bluesky",
-        accountId: this.getAccountId(),
-        provider: "bluesky",
-        timestamp: createdAt,
-        fromBot: entityId === runtime.agentId,
-        messageIdFull: post.uri,
-        chatType: import_core4.ChannelType.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 = import_core4.composePrompt({
-      state: {
-        maxLength: String(BLUESKY_MAX_POST_LENGTH)
-      },
-      template: generatePostTemplate
-    });
-    const response = await this.runtime.useModel(import_core4.ModelType.TEXT_SMALL, {
-      prompt,
-      maxTokens: 100
-    });
-    return response;
-  }
-  async truncate(text) {
-    const prompt = import_core4.composePrompt({
-      state: {
-        maxLength: String(BLUESKY_MAX_POST_LENGTH),
-        text
-      },
-      template: truncatePostTemplate
-    });
-    const response = await this.runtime.useModel(import_core4.ModelType.TEXT_SMALL, {
-      prompt,
-      maxTokens: 100
-    });
-    const truncated = response;
-    return truncated.length > BLUESKY_MAX_POST_LENGTH ? `${truncated.substring(0, BLUESKY_MAX_POST_LENGTH - 3)}...` : truncated;
-  }
-}
-
-// services/bluesky.ts
-class BlueSkyService extends import_core5.Service {
-  static instance;
-  agents = new Map;
-  static serviceType = BLUESKY_SERVICE_NAME;
-  capabilityDescription = "Send and receive messages on BlueSky";
-  static getInstance() {
-    BlueSkyService.instance ??= new BlueSkyService;
-    return BlueSkyService.instance;
-  }
-  static async start(runtime) {
-    const service = BlueSkyService.getInstance();
-    if (service.agents.has(runtime.agentId)) {
-      return service;
-    }
-    if (!hasBlueSkyEnabled(runtime)) {
-      return service;
-    }
-    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) {
-        import_core5.logger.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();
-      import_core5.logger.success({ agentId: runtime.agentId, accountId }, "BlueSky client started");
-    }
-    return service;
-  }
-  static async stop(runtime) {
-    const service = BlueSkyService.getInstance();
-    const accounts = service.agents.get(runtime.agentId);
-    if (!accounts)
-      return;
-    for (const manager of accounts.managers.values()) {
-      await manager.stop();
-    }
-    service.agents.delete(runtime.agentId);
-    import_core5.logger.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: import_core5.ChannelType.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: import_core5.ChannelType.FEED
-        }
-      }
-    });
-    runtime.logger.info({ src: "plugin:bluesky", agentId: runtime.agentId, accountId }, "Registered BlueSky post connector");
-  }
-  async stop() {
-    for (const [agentId, accounts] of this.agents) {
-      for (const manager of accounts.managers.values()) {
-        await manager.stop();
-      }
-      this.agents.delete(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;
-  }
-  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
-var import_core6 = require("@elizaos/core");
-var WORKFLOW_CREDENTIAL_PROVIDER_TYPE = "workflow_credential_provider";
-var SUPPORTED = ["httpHeaderAuth"];
-
-class BlueskyWorkflowCredentialProvider extends import_core6.Service {
-  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))
-    };
-  }
-}
-
-// index.ts
-var pluginTests = [
-  {
-    name: "bluesky_plugin_tests",
-    tests: [
-      {
-        name: "bluesky_test_credentials_validation",
-        fn: async (runtime) => {
-          const handle = getApiKeyOptional(runtime, "BLUESKY_HANDLE");
-          const password = getApiKeyOptional(runtime, "BLUESKY_PASSWORD");
-          if (!handle || !password) {
-            throw new Error("BLUESKY_HANDLE and BLUESKY_PASSWORD are not configured");
-          }
-          import_core7.logger.log("BlueSky credentials are configured");
-        }
-      },
-      {
-        name: "bluesky_test_service_initialization",
-        fn: async (runtime) => {
-          const handle = getApiKeyOptional(runtime, "BLUESKY_HANDLE");
-          const password = getApiKeyOptional(runtime, "BLUESKY_PASSWORD");
-          if (!handle || !password) {
-            import_core7.logger.log("Skipping service initialization test - credentials not configured");
-            return;
-          }
-          const service = await BlueSkyService.start(runtime);
-          if (!service) {
-            throw new Error("Failed to initialize BlueSky service");
-          }
-          import_core7.logger.log("BlueSky service initialized successfully");
-        }
-      }
-    ]
-  }
-];
-var blueSkyPlugin = {
-  name: "bluesky",
-  description: "BlueSky client plugin using AT Protocol for social interactions",
-  config: {
-    BLUESKY_HANDLE: process.env.BLUESKY_HANDLE ?? null,
-    BLUESKY_PASSWORD: process.env.BLUESKY_PASSWORD ?? null,
-    BLUESKY_SERVICE: process.env.BLUESKY_SERVICE ?? null,
-    BLUESKY_DRY_RUN: process.env.BLUESKY_DRY_RUN ?? null,
-    BLUESKY_POLL_INTERVAL: process.env.BLUESKY_POLL_INTERVAL ?? null,
-    BLUESKY_ENABLE_POSTING: process.env.BLUESKY_ENABLE_POSTING ?? null,
-    BLUESKY_ENABLE_DMS: process.env.BLUESKY_ENABLE_DMS ?? null,
-    BLUESKY_POST_INTERVAL_MIN: process.env.BLUESKY_POST_INTERVAL_MIN ?? null,
-    BLUESKY_POST_INTERVAL_MAX: process.env.BLUESKY_POST_INTERVAL_MAX ?? null,
-    BLUESKY_ENABLE_ACTION_PROCESSING: process.env.BLUESKY_ENABLE_ACTION_PROCESSING ?? null,
-    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_ACCOUNTS: process.env.BLUESKY_ACCOUNTS ?? null,
-    BLUESKY_DEFAULT_ACCOUNT_ID: process.env.BLUESKY_DEFAULT_ACCOUNT_ID ?? null
-  },
-  async init(_config, runtime) {
-    try {
-      const manager = import_core7.getConnectorAccountManager(runtime);
-      manager.registerProvider(createBlueSkyConnectorAccountProvider(runtime));
-    } catch (err) {
-      import_core7.logger.warn({
-        src: "plugin:bluesky",
-        err: err instanceof Error ? err.message : String(err)
-      }, "Failed to register BlueSky provider with ConnectorAccountManager");
-    }
-    import_core7.logger.log("BlueSky plugin initialized");
-  },
-  actions: [],
-  services: [BlueSkyService, BlueskyWorkflowCredentialProvider],
-  tests: pluginTests
-};
-
-//# debugId=3E81B0DAACB595C464756E2164756E21