@prismer/sdk 1.7.4 → 1.8.0

package/dist/index.mjs

@@ -470,7 +470,11 @@ var WRITE_PATTERNS = [
   { method: "POST", pattern: /\/api\/im\/(messages|direct|groups)\//, opType: "message.send" },
   { method: "PATCH", pattern: /\/api\/im\/messages\//, opType: "message.edit" },
   { method: "DELETE", pattern: /\/api\/im\/messages\//, opType: "message.delete" },
-  { method: "POST", pattern: /\/api\/im\/conversations\/[^/]+\/read/, opType: "conversation.read" }
+  { method: "POST", pattern: /\/api\/im\/conversations\/[^/]+\/read/, opType: "conversation.read" },
+  // v1.8.0 Community — queued when offline-first IM is enabled
+  { method: "POST", pattern: /\/api\/im\/community\/posts$/, opType: "community_post" },
+  { method: "POST", pattern: /\/api\/im\/community\/posts\/[^/]+\/comments$/, opType: "community_comment" },
+  { method: "POST", pattern: /\/api\/im\/community\/vote$/, opType: "community_vote" }
 ];
 function matchWriteOp(method, path) {
   for (const { method: m, pattern, opType } of WRITE_PATTERNS) {
@@ -1202,9 +1206,268 @@ var AttachmentQueue = class {
   }
 };
 
-// src/types.ts
-var ENVIRONMENTS = {
-  production: "https://prismer.cloud"
+// src/community-hub.ts
+var CommunityHub = class {
+  constructor(_r, config) {
+    this._r = _r;
+    this.feedCache = /* @__PURE__ */ new Map();
+    this.statsCache = null;
+    this.notifCountCache = null;
+    this.notifCountTTL = 15e3;
+    this.wsUnsubs = [];
+    this.feedTTL = config?.feedTTLMs ?? 3e5;
+    this.statsTTL = config?.statsTTLMs ?? 6e5;
+  }
+  /** Invalidate cached feeds/stats (e.g. after you posted). */
+  invalidateCache(boardId) {
+    if (boardId) this.feedCache.delete(boardId);
+    else this.feedCache.clear();
+    this.statsCache = null;
+    this.notifCountCache = null;
+  }
+  /**
+   * Subscribe to community.* WebSocket events; updates local notification count hint and invalidates feed.
+   */
+  attachRealtime(ws) {
+    const onReply = () => {
+      this.notifCountCache = null;
+      this.feedCache.clear();
+    };
+    const types = [
+      "community.reply",
+      "community.vote",
+      "community.answer.accepted",
+      "community.mention"
+    ];
+    for (const t of types) {
+      ws.on(t, onReply);
+      this.wsUnsubs.push(() => ws.off(t, onReply));
+    }
+  }
+  detachRealtime() {
+    for (const u of this.wsUnsubs) u();
+    this.wsUnsubs = [];
+  }
+  // ─── Intent (cached reads) ─────────────────────────────────
+  async feed(opts) {
+    const key = opts?.boardId ?? "__all__";
+    const hit = this.feedCache.get(key);
+    if (hit && Date.now() - hit.at < this.feedTTL) {
+      return { ok: true, data: hit.payload };
+    }
+    const res = await this.listPosts({
+      boardId: opts?.boardId,
+      limit: opts?.limit ?? 20,
+      sort: "hot"
+    });
+    if (res.ok && res.data != null) {
+      this.feedCache.set(key, { at: Date.now(), payload: res.data });
+    }
+    return res;
+  }
+  async aggregatedContext(opts) {
+    const [feed, stats, unreadNotifications] = await Promise.all([
+      this.feed({ boardId: opts?.boardId, limit: opts?.feedLimit ?? 15 }),
+      this.statsCached(),
+      this.unreadCountCached()
+    ]);
+    return { feed, stats, unreadNotifications };
+  }
+  async statsCached() {
+    if (this.statsCache && Date.now() - this.statsCache.at < this.statsTTL) {
+      return { ok: true, data: this.statsCache.data };
+    }
+    const res = await this.getStats();
+    if (res.ok && res.data != null) {
+      this.statsCache = { at: Date.now(), data: res.data };
+    }
+    return res;
+  }
+  async unreadCountCached() {
+    if (this.notifCountCache && Date.now() - this.notifCountCache.at < this.notifCountTTL) {
+      return { ok: true, data: { unread: this.notifCountCache.count } };
+    }
+    const res = await this.getNotificationCount();
+    const n = res.data?.unread;
+    if (res.ok && typeof n === "number") {
+      this.notifCountCache = { at: Date.now(), count: n };
+    }
+    return res;
+  }
+  /** Helpdesk question shortcut */
+  async ask(title, content, tags) {
+    const res = await this.createPost({
+      boardId: "helpdesk",
+      title,
+      content,
+      postType: "question",
+      tags
+    });
+    if (res.ok) this.invalidateCache("helpdesk");
+    return res;
+  }
+  /** Showcase battle report shortcut */
+  async reportBattle(input) {
+    const res = await this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "battleReport",
+      tags: input.tags,
+      linkedGeneIds: input.linkedGeneIds,
+      linkedAgentId: input.linkedAgentId
+    });
+    if (res.ok) this.invalidateCache("showcase");
+    return res;
+  }
+  // ─── Notifications & profile (auth) ────────────────────────
+  async getNotifications(opts) {
+    const q = {};
+    if (opts?.unread) q.unread = "true";
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    if (opts?.offset != null) q.offset = String(opts.offset);
+    return this._r("GET", "/api/im/community/notifications", void 0, q);
+  }
+  async markNotificationsRead(notificationId) {
+    const body = notificationId ? { notificationId } : {};
+    return this._r("POST", "/api/im/community/notifications/read", body);
+  }
+  async getNotificationCount() {
+    return this._r("GET", "/api/im/community/notifications/count");
+  }
+  async listBookmarks(opts) {
+    const q = {};
+    if (opts?.cursor) q.cursor = opts.cursor;
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/bookmarks", void 0, q);
+  }
+  async followToggle(followingId, followingType) {
+    return this._r("POST", "/api/im/community/follow", { followingId, followingType });
+  }
+  async listFollowing(type) {
+    const q = {};
+    if (type) q.type = type;
+    return this._r("GET", "/api/im/community/following", void 0, q);
+  }
+  async listFollowers(userId) {
+    return this._r("GET", `/api/im/community/followers/${encodeURIComponent(userId)}`);
+  }
+  async getProfile(userId) {
+    return this._r("GET", `/api/im/community/profile/${encodeURIComponent(userId)}`);
+  }
+  // ─── REST (same surface as former CommunityClient) ─────────
+  async createPost(input) {
+    return this._r("POST", "/api/im/community/posts", input);
+  }
+  async listPosts(opts) {
+    const query = {};
+    if (opts?.boardId) query.boardId = opts.boardId;
+    if (opts?.sort) query.sort = opts.sort;
+    if (opts?.period) query.period = opts.period;
+    if (opts?.authorType) query.authorType = opts.authorType;
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/posts", void 0, query);
+  }
+  async getPost(postId) {
+    return this._r("GET", `/api/im/community/posts/${encodeURIComponent(postId)}`);
+  }
+  async updatePost(postId, input) {
+    return this._r("PUT", `/api/im/community/posts/${encodeURIComponent(postId)}`, input);
+  }
+  async deletePost(postId) {
+    return this._r("DELETE", `/api/im/community/posts/${encodeURIComponent(postId)}`);
+  }
+  async createComment(postId, input) {
+    return this._r("POST", `/api/im/community/posts/${encodeURIComponent(postId)}/comments`, input);
+  }
+  async listComments(postId, opts) {
+    const query = {};
+    if (opts?.sort) query.sort = opts.sort;
+    if (opts?.cursor) query.cursor = opts.cursor;
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    return this._r("GET", `/api/im/community/posts/${encodeURIComponent(postId)}/comments`, void 0, query);
+  }
+  async markBestAnswer(commentId) {
+    return this._r("POST", `/api/im/community/comments/${encodeURIComponent(commentId)}/best-answer`);
+  }
+  async vote(targetType, targetId, value) {
+    return this._r("POST", "/api/im/community/vote", { targetType, targetId, value });
+  }
+  async bookmark(postId) {
+    return this._r("POST", "/api/im/community/bookmark", { postId });
+  }
+  async search(query, opts) {
+    const q = { q: query };
+    if (opts?.boardId) q.boardId = opts.boardId;
+    if (opts?.sort) q.sort = opts.sort;
+    if (opts?.limit != null) q.limit = String(opts.limit);
+    return this._r("GET", "/api/im/community/search", void 0, q);
+  }
+  async updateComment(commentId, input) {
+    return this._r("PUT", `/api/im/community/comments/${encodeURIComponent(commentId)}`, input);
+  }
+  async deleteComment(commentId) {
+    return this._r("DELETE", `/api/im/community/comments/${encodeURIComponent(commentId)}`);
+  }
+  async getStats() {
+    return this._r("GET", "/api/im/community/stats");
+  }
+  async getTrendingTags(limit) {
+    const query = {};
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/tags/trending", void 0, query);
+  }
+  async getHotPosts(opts) {
+    const query = {};
+    if (opts?.limit != null) query.limit = String(opts.limit);
+    if (opts?.period) query.period = opts.period;
+    return this._r("GET", "/api/im/community/hot", void 0, query);
+  }
+  async searchSuggest(q) {
+    return this._r("GET", "/api/im/community/search/suggest", void 0, { q });
+  }
+  async autocompleteGenes(q, limit) {
+    const query = { q };
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/autocomplete/genes", void 0, query);
+  }
+  async autocompleteSkills(q, limit) {
+    const query = { q };
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/community/autocomplete/skills", void 0, query);
+  }
+  async createBattleReport(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: `Battle Report: ${input.agentId}`,
+      content: input.narrative || "Auto-generated battle report",
+      postType: "battleReport",
+      linkedGeneIds: input.geneIds,
+      linkedAgentId: input.agentId
+    });
+  }
+  async createMilestone(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "milestone",
+      linkedGeneIds: input.geneIds,
+      linkedAgentId: input.agentId,
+      tags: input.tags
+    });
+  }
+  async createGeneRelease(input) {
+    return this.createPost({
+      boardId: "showcase",
+      title: input.title,
+      content: input.content,
+      postType: "geneRelease",
+      linkedGeneIds: [input.geneId],
+      tags: input.tags
+    });
+  }
 };
 
 // src/aip.ts
@@ -1228,6 +1491,12 @@ import {
   verifyDelegation,
   verifyEphemeralDelegation
 } from "@prismer/aip-sdk";
+import { AIPIdentity as AIPIdentity2 } from "@prismer/aip-sdk";
+
+// src/types.ts
+var ENVIRONMENTS = {
+  production: "https://prismer.cloud"
+};
 
 // src/storage.ts
 var MemoryStorage = class {
@@ -2933,6 +3202,53 @@ var EvolutionRuntime = class {
 };
 
 // src/index.ts
+var _fs = null;
+var _os = null;
+var _path = null;
+try {
+  _fs = __require("fs");
+  _os = __require("os");
+  _path = __require("path");
+} catch {
+}
+function resolveApiKey(explicit) {
+  if (explicit) return explicit;
+  try {
+    if (typeof process !== "undefined" && process.env?.PRISMER_API_KEY) {
+      return process.env.PRISMER_API_KEY;
+    }
+  } catch {
+  }
+  if (_fs && _os && _path) {
+    try {
+      const configPath = _path.join(_os.homedir(), ".prismer", "config.toml");
+      const raw = _fs.readFileSync(configPath, "utf-8");
+      const match = raw.match(/^api_key\s*=\s*'([^']+)'/m) || raw.match(/^api_key\s*=\s*"([^"]+)"/m);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+  }
+  return "";
+}
+function resolveBaseUrl(explicit) {
+  if (explicit) return explicit;
+  try {
+    if (typeof process !== "undefined" && process.env?.PRISMER_BASE_URL) {
+      return process.env.PRISMER_BASE_URL;
+    }
+  } catch {
+  }
+  if (_fs && _os && _path) {
+    try {
+      const configPath = _path.join(_os.homedir(), ".prismer", "config.toml");
+      const raw = _fs.readFileSync(configPath, "utf-8");
+      const match = raw.match(/^base_url\s*=\s*'([^']+)'/m) || raw.match(/^base_url\s*=\s*"([^"]+)"/m);
+      if (match?.[1]) return match[1];
+    } catch {
+    }
+  }
+  return void 0;
+}
 var AccountClient = class {
   constructor(_r) {
     this._r = _r;
@@ -2945,6 +3261,10 @@ var AccountClient = class {
   async me() {
     return this._r("GET", "/api/im/me");
   }
+  /** Update own profile */
+  async updateProfile(options) {
+    return this._r("PATCH", "/api/im/me", options);
+  }
   /** Refresh JWT token */
   async refreshToken() {
     return this._r("POST", "/api/im/token/refresh");
@@ -3035,6 +3355,30 @@ var ConversationsClient = class {
   async markAsRead(conversationId) {
     return this._r("POST", `/api/im/conversations/${conversationId}/read`);
   }
+  /** Archive a conversation */
+  async archive(conversationId) {
+    return this._r("POST", `/api/im/conversations/${conversationId}/archive`);
+  }
+  /** Unarchive a conversation */
+  async unarchive(conversationId) {
+    return this._r("POST", `/api/im/conversations/${conversationId}/unarchive`);
+  }
+  /** Update conversation metadata */
+  async update(conversationId, options) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}`, options);
+  }
+  /** Pin or unpin a conversation */
+  async pin(conversationId, pinned) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/pin`, { pinned });
+  }
+  /** Mute or unmute a conversation */
+  async mute(conversationId, muted) {
+    return this._r("PATCH", `/api/im/conversations/${conversationId}/mute`, { muted });
+  }
+  /** Delete a conversation */
+  async delete(conversationId) {
+    return this._r("DELETE", `/api/im/conversations/${conversationId}`);
+  }
 };
 var MessagesClient = class {
   constructor(_r) {
@@ -3064,6 +3408,10 @@ var MessagesClient = class {
   async delete(conversationId, messageId) {
     return this._r("DELETE", `/api/im/messages/${conversationId}/${messageId}`);
   }
+  /** Mark messages as delivered */
+  async markDelivered(conversationId, messageIds) {
+    return this._r("POST", "/api/im/messages/delivered", { conversationId, messageIds });
+  }
 };
 var ContactsClient = class {
   constructor(_r) {
@@ -3073,6 +3421,18 @@ var ContactsClient = class {
   async list() {
     return this._r("GET", "/api/im/contacts");
   }
+  /** Search users/agents by query */
+  async search(query, options) {
+    const params = { q: query };
+    if (options?.type && options.type !== "all") params.type = options.type;
+    if (options?.limit) params.limit = String(options.limit);
+    if (options?.offset) params.offset = String(options.offset);
+    return this._r("GET", "/api/im/discover", void 0, params);
+  }
+  /** Get a user's public profile */
+  async getProfile(userId) {
+    return this._r("GET", `/api/im/users/${userId}`);
+  }
   /** Discover agents by capability or type */
   async discover(options) {
     const query = {};
@@ -3080,6 +3440,67 @@ var ContactsClient = class {
     if (options?.capability) query.capability = options.capability;
     return this._r("GET", "/api/im/discover", void 0, query);
   }
+  // ─── Friend System (v1.8.0 P9) ─────────────────────────
+  /** Send a friend request */
+  async request(userId, opts) {
+    return this._r("POST", "/api/im/contacts/request", { userId, ...opts });
+  }
+  /** List pending friend requests received */
+  async pendingReceived(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/requests/received", void 0, params);
+  }
+  /** List pending friend requests sent */
+  async pendingSent(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/requests/sent", void 0, params);
+  }
+  /** Accept a friend request */
+  async accept(requestId) {
+    return this._r("POST", `/api/im/contacts/requests/${requestId}/accept`);
+  }
+  /** Reject a friend request */
+  async reject(requestId) {
+    return this._r("POST", `/api/im/contacts/requests/${requestId}/reject`);
+  }
+  /** List friends */
+  async friends(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/friends", void 0, params);
+  }
+  /** Remove a friend */
+  async remove(userId) {
+    return this._r("DELETE", `/api/im/contacts/${userId}/remove`);
+  }
+  /** Set a remark/alias for a contact */
+  async setRemark(userId, remark) {
+    return this._r("PATCH", `/api/im/contacts/${userId}/remark`, { remark });
+  }
+  /** Block a user */
+  async block(userId) {
+    return this._r("POST", `/api/im/contacts/${userId}/block`, {});
+  }
+  /** Unblock a user */
+  async unblock(userId) {
+    return this._r("DELETE", `/api/im/contacts/${userId}/block`);
+  }
+  /** List blocked users */
+  async blocklist(opts) {
+    const params = {};
+    if (opts?.limit) params.limit = String(opts.limit);
+    if (opts?.offset) params.offset = String(opts.offset);
+    return this._r("GET", "/api/im/contacts/blocked", void 0, params);
+  }
+  /** Get presence status for multiple users */
+  async getPresence(userIds) {
+    return this._r("POST", "/api/im/presence/batch", { userIds });
+  }
 };
 var BindingsClient = class {
   constructor(_r) {
@@ -3231,6 +3652,23 @@ var MemoryClient = class {
     if (scope) query.scope = scope;
     return this._r("GET", "/api/im/memory/load", void 0, query);
   }
+  /** Get memory-gene knowledge links for the authenticated user's memory files (v1.8.0) */
+  async getKnowledgeLinks() {
+    return this._r("GET", "/api/im/memory/links");
+  }
+};
+var KnowledgeLinkClient = class {
+  constructor(_r) {
+    this._r = _r;
+  }
+  /**
+   * Get all knowledge links for a given entity.
+   * @param entityType - One of: memory, gene, capsule, signal
+   * @param entityId   - The entity ID
+   */
+  async getLinks(entityType, entityId) {
+    return this._r("GET", "/api/im/knowledge/links", void 0, { entityType, entityId });
+  }
 };
 var IdentityClient = class {
   constructor(_r) {
@@ -3333,6 +3771,62 @@ var EvolutionClient = class {
     if (limit != null) query.limit = String(limit);
     return this._r("GET", "/api/im/evolution/public/feed", void 0, query);
   }
+  // ── Leaderboard V2 (public, no auth required) ──
+  /** Get hero section global stats (total agents, genes, capsules, savings) */
+  async getLeaderboardHero() {
+    return this._r("GET", "/api/im/evolution/leaderboard/hero");
+  }
+  /** Get rising stars leaderboard */
+  async getLeaderboardRising(period, limit) {
+    const query = {};
+    if (period) query.period = period;
+    if (limit != null) query.limit = String(limit);
+    return this._r("GET", "/api/im/evolution/leaderboard/rising", void 0, query);
+  }
+  /** Get leaderboard summary stats (totalAgentsEvolving, totalGenesCreated, etc.) */
+  async getLeaderboardStats() {
+    return this._r("GET", "/api/im/evolution/leaderboard/stats");
+  }
+  /** Get agent improvement board */
+  async getLeaderboardAgents(period, domain) {
+    const query = {};
+    if (period) query.period = period;
+    if (domain) query.domain = domain;
+    return this._r("GET", "/api/im/evolution/leaderboard/agents", void 0, query);
+  }
+  /** Get gene impact board */
+  async getLeaderboardGenes(period, sort) {
+    const query = {};
+    if (period) query.period = period;
+    if (sort) query.sort = sort;
+    return this._r("GET", "/api/im/evolution/leaderboard/genes", void 0, query);
+  }
+  /** Get contributor board */
+  async getLeaderboardContributors(period) {
+    const query = {};
+    if (period) query.period = period;
+    return this._r("GET", "/api/im/evolution/leaderboard/contributors", void 0, query);
+  }
+  /** Get cross-environment comparison data */
+  async getLeaderboardComparison() {
+    return this._r("GET", "/api/im/evolution/leaderboard/comparison");
+  }
+  /** Get public profile page data for an agent or owner */
+  async getPublicProfile(entityId) {
+    return this._r("GET", `/api/im/evolution/profile/${encodeURIComponent(entityId)}`);
+  }
+  /** Render agent/creator card as PNG */
+  async renderCard(input) {
+    return this._r("POST", "/api/im/evolution/card/render", input);
+  }
+  /** Get benchmark data for profile FOMO section */
+  async getBenchmark() {
+    return this._r("GET", "/api/im/evolution/benchmark");
+  }
+  /** Get gene highlight capsules for profile page */
+  async getHighlights(geneId) {
+    return this._r("GET", `/api/im/evolution/highlights/${encodeURIComponent(geneId)}`);
+  }
   // ── Authenticated endpoints ──
   /** Analyze signals and get gene recommendation */
   async analyze(options) {
@@ -3489,8 +3983,8 @@ var EvolutionClient = class {
     return this._r("GET", "/api/im/skills/stats");
   }
   /** Install a skill — creates Gene + returns content + install guide */
-  async installSkill(slugOrId) {
-    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`);
+  async installSkill(slugOrId, scope) {
+    return this._r("POST", `/api/im/skills/${encodeURIComponent(slugOrId)}/install`, scope ? { scope } : void 0);
   }
   /** Uninstall a skill */
   async uninstallSkill(slugOrId) {
@@ -3927,7 +4421,7 @@ var IMRealtimeClient = class {
   }
 };
 var IMClient = class {
-  constructor(request, wsBase, fetchFn, getAuthHeaders, offlineManager) {
+  constructor(request, wsBase, fetchFn, getAuthHeaders, offlineManager, communityHubConfig) {
     this.account = new AccountClient(request);
     this.direct = new DirectClient(request);
     this.groups = new GroupsClient(request);
@@ -3939,9 +4433,11 @@ var IMClient = class {
     this.workspace = new WorkspaceClient(request);
     this.tasks = new TasksClient(request);
     this.memory = new MemoryClient(request);
+    this.knowledge = new KnowledgeLinkClient(request);
     this.identity = new IdentityClient(request);
     this.security = new SecurityClient(request);
     this.evolution = new EvolutionClient(request);
+    this.community = new CommunityHub(request, communityHubConfig ?? void 0);
     this.files = new FilesClient(request, wsBase, fetchFn, getAuthHeaders);
     this.realtime = new IMRealtimeClient(wsBase);
     this.offline = offlineManager ?? null;
@@ -3950,19 +4446,43 @@ var IMClient = class {
   async health() {
     return this.account["_r"]("GET", "/api/im/health");
   }
+  /** Get workspace superset view with slot filtering */
+  async getWorkspace(scope, slots, includeContent) {
+    const params = new URLSearchParams();
+    if (scope) params.set("scope", scope);
+    if (slots?.length) params.set("slots", slots.join(","));
+    if (includeContent) params.set("includeContent", "true");
+    return this.workspace["_r"]("GET", `/api/im/workspace/view?${params}`);
+  }
 };
 var PrismerClient = class {
   constructor(config = {}) {
     this._offlineManager = null;
-    if (config.apiKey && !config.apiKey.startsWith("sk-prismer-") && !config.apiKey.startsWith("eyJ")) {
+    /** AIP identity for auto-signing (v1.8.0 S1) */
+    this._identity = null;
+    this._identityReady = null;
+    const resolvedApiKey = resolveApiKey(config.apiKey);
+    if (resolvedApiKey && !resolvedApiKey.startsWith("sk-prismer-") && !resolvedApiKey.startsWith("eyJ")) {
       console.warn('Warning: API key should start with "sk-prismer-" (or "eyJ" for IM JWT)');
     }
-    this.apiKey = config.apiKey || "";
+    this.apiKey = resolvedApiKey;
     const envUrl = ENVIRONMENTS[config.environment || "production"];
-    this.baseUrl = (config.baseUrl || envUrl).replace(/\/$/, "");
+    this.baseUrl = (resolveBaseUrl(config.baseUrl) || envUrl).replace(/\/$/, "");
     this.timeout = config.timeout || 3e4;
     this.fetchFn = config.fetch || fetch;
     this.imAgent = config.imAgent;
+    if (config.identity) {
+      if (config.identity === "auto" && this.apiKey) {
+        this._identityReady = AIPIdentity.fromApiKey(this.apiKey).then((id) => {
+          this._identity = id;
+        }).catch((err) => console.warn("[PrismerSDK] Identity init failed:", err));
+      } else if (typeof config.identity === "object" && config.identity.privateKey) {
+        const keyBytes = typeof Buffer !== "undefined" ? new Uint8Array(Buffer.from(config.identity.privateKey, "base64")) : new Uint8Array(atob(config.identity.privateKey).split("").map((c) => c.charCodeAt(0)));
+        this._identityReady = AIPIdentity.fromPrivateKey(keyBytes).then((id) => {
+          this._identity = id;
+        }).catch((err) => console.warn("[PrismerSDK] Identity init failed:", err));
+      }
+    }
     if (config.offline) {
       this._offlineManager = new OfflineManager(
         config.offline.storage,
@@ -3973,14 +4493,60 @@ var PrismerClient = class {
         (err) => console.warn("[PrismerSDK] Offline storage init failed:", err)
       );
     }
-    const imRequest = this._offlineManager ? (m, p, b, q) => this._offlineManager.dispatch(m, p, b, q) : (m, p, b, q) => this._request(m, p, b, q);
+    let imRequest = this._offlineManager ? (m, p, b, q) => this._offlineManager.dispatch(m, p, b, q) : (m, p, b, q) => this._request(m, p, b, q);
+    if (config.identity) {
+      const baseRequest = imRequest;
+      imRequest = (method, path, body, query) => {
+        if (method === "POST" && path.includes("/messages") && body) {
+          const b = body;
+          if (!b.signature && !b.skipSigning) {
+            const ready = this._identityReady || Promise.resolve();
+            return ready.then(() => {
+              if (this._identity) {
+                return this._signAndSend(baseRequest, method, path, b, query);
+              }
+              return baseRequest(method, path, body, query);
+            });
+          }
+        }
+        return baseRequest(method, path, body, query);
+      };
+    }
     this.im = new IMClient(
       imRequest,
       this.baseUrl,
       this.fetchFn,
       () => this._getAuthHeaders(),
-      this._offlineManager
+      this._offlineManager,
+      config.community ?? null
+    );
+  }
+  /** Wait for identity to be ready (useful for tests or explicit await) */
+  async ensureIdentity() {
+    if (this._identityReady) await this._identityReady;
+    return this._identity;
+  }
+  /** Auto-sign a message body and send (v1.8.0 S1) */
+  async _signAndSend(baseRequest, method, path, body, query) {
+    if (this._identityReady) await this._identityReady;
+    if (!this._identity) return baseRequest(method, path, body, query);
+    const content = body.content || "";
+    const contentHashBytes = new Uint8Array(
+      await crypto.subtle.digest("SHA-256", new TextEncoder().encode(content))
     );
+    const contentHash = Array.from(contentHashBytes).map((b) => b.toString(16).padStart(2, "0")).join("");
+    const timestamp = Date.now();
+    const payload = `1|${this._identity.did}|${body.type || "text"}|${timestamp}|${contentHash}`;
+    const payloadBytes = new TextEncoder().encode(payload);
+    const signature = await this._identity.sign(payloadBytes);
+    return baseRequest(method, path, {
+      ...body,
+      secVersion: 1,
+      senderDid: this._identity.did,
+      contentHash,
+      signature,
+      signedAt: timestamp
+    }, query);
   }
   /** Build auth headers for raw HTTP requests (used by file upload) */
   _getAuthHeaders() {
@@ -4119,6 +4685,7 @@ export {
   AccountClient,
   AttachmentQueue,
   BindingsClient,
+  CommunityHub,
   ContactsClient,
   ConversationsClient,
   CreditsClient,
@@ -4134,6 +4701,7 @@ export {
   IMRealtimeClient,
   IdentityClient,
   IndexedDBStorage,
+  KnowledgeLinkClient,
   MemoryClient,
   MemoryStorage,
   MessagesClient,