@memtensor/memos-local-openclaw-plugin 1.0.4-beta.2 → 1.0.4-beta.20

package/src/hub/user-manager.ts

@@ -1,16 +1,27 @@
 import { randomUUID, createHash } from "crypto";
-import { issueUserToken } from "./auth";
+import { issueUserToken, verifyUserToken } from "./auth";
 import type { Logger } from "../types";
 import type { UserInfo } from "../sharing/types";
 import type { SqliteStore } from "../storage/sqlite";
 
-type ManagedHubUser = UserInfo & { tokenHash: string; createdAt: number; approvedAt: number | null };
+type ManagedHubUser = UserInfo & {
+  tokenHash: string;
+  createdAt: number;
+  approvedAt: number | null;
+  lastIp: string;
+  lastActiveAt: number | null;
+  identityKey?: string;
+  leftAt?: number | null;
+  removedAt?: number | null;
+  rejectedAt?: number | null;
+  rejoinRequestedAt?: number | null;
+};
 
 export class HubUserManager {
   constructor(private store: SqliteStore, private log: Logger) {}
 
-  createPendingUser(input: { username: string; deviceName?: string }): ManagedHubUser {
-    const user = {
+  createPendingUser(input: { username: string; deviceName?: string; identityKey?: string }): ManagedHubUser {
+    const user: ManagedHubUser = {
       id: randomUUID(),
       username: input.username,
       deviceName: input.deviceName,
@@ -20,11 +31,38 @@ export class HubUserManager {
       tokenHash: "",
       createdAt: Date.now(),
       approvedAt: null,
+      lastIp: "",
+      lastActiveAt: null,
+      identityKey: input.identityKey || "",
     };
     this.store.upsertHubUser(user);
     return user;
   }
 
+  findByIdentityKey(identityKey: string): ManagedHubUser | null {
+    if (!identityKey) return null;
+    return this.store.findHubUserByIdentityKey(identityKey);
+  }
+
+  markUserLeft(userId: string): boolean {
+    this.log.info(`Hub: user "${userId}" marked as left`);
+    return this.store.markHubUserLeft(userId);
+  }
+
+  rejoinUser(userId: string): ManagedHubUser | null {
+    const user = this.store.getHubUser(userId);
+    if (!user) return null;
+    const updated: ManagedHubUser = {
+      ...user,
+      status: "pending" as const,
+      tokenHash: "",
+      rejoinRequestedAt: Date.now(),
+    };
+    this.store.upsertHubUser(updated);
+    this.log.info(`Hub: user "${userId}" (${user.username}) requested rejoin, previous status: ${user.status}`);
+    return updated;
+  }
+
   listPendingUsers(): ManagedHubUser[] {
     return this.store.listHubUsers("pending");
   }
@@ -46,7 +84,7 @@ export class HubUserManager {
     if (bootstrapUserId) {
       const bootstrapUser = this.store.getHubUser(bootstrapUserId);
       if (bootstrapUser && bootstrapUser.role === "admin" && bootstrapUser.status === "active") {
-        if (bootstrapToken && bootstrapUser.tokenHash === createHash("sha256").update(bootstrapToken).digest("hex")) {
+        if (bootstrapToken && bootstrapUser.tokenHash === createHash("sha256").update(bootstrapToken).digest("hex") && verifyUserToken(bootstrapToken, secret)) {
           return { user: bootstrapUser, token: bootstrapToken };
         }
         const refreshedToken = issueUserToken(
@@ -88,6 +126,8 @@ export class HubUserManager {
       tokenHash: "",
       createdAt: Date.now(),
       approvedAt: Date.now(),
+      lastIp: "",
+      lastActiveAt: null,
     };
     const token = issueUserToken(
       { userId: user.id, username: user.username, role: user.role, status: user.status },
@@ -101,7 +141,7 @@ export class HubUserManager {
 
   isUsernameTaken(username: string, excludeUserId?: string): boolean {
     const users = this.store.listHubUsers();
-    return users.some(u => u.username === username && u.id !== excludeUserId);
+    return users.some(u => u.username === username && u.id !== excludeUserId && u.status !== "left" && u.status !== "removed");
   }
 
   updateUsername(userId: string, newUsername: string): ManagedHubUser | null {
@@ -115,10 +155,10 @@ export class HubUserManager {
   rejectUser(userId: string): ManagedHubUser | null {
     const user = this.store.getHubUser(userId);
     if (!user) return null;
-    const updated = {
+    const updated: ManagedHubUser = {
       ...user,
       status: "rejected" as const,
-      approvedAt: Date.now(),
+      rejectedAt: Date.now(),
     };
     this.store.upsertHubUser(updated);
     return updated;

package/src/index.ts

@@ -1,5 +1,6 @@
 import { v4 as uuid } from "uuid";
 import { buildContext } from "./config";
+import { ensureSqliteBinding } from "./storage/ensure-binding";
 import { SqliteStore } from "./storage/sqlite";
 import { Embedder } from "./embedding";
 import { IngestWorker } from "./ingest/worker";
@@ -56,13 +57,17 @@ export function initPlugin(opts: PluginInitOptions = {}): MemosLocalPlugin {
 
   ctx.log.info("Initializing memos-local plugin...");
 
+  ensureSqliteBinding(ctx.log);
+
   const store = new SqliteStore(ctx.config.storage!.dbPath!, ctx.log);
   const embedder = new Embedder(ctx.config.embedding, ctx.log, ctx.openclawAPI);
   const worker = new IngestWorker(store, embedder, ctx);
   const engine = new RecallEngine(store, embedder, ctx);
 
+  const sharedState = { lastSearchTime: 0 };
+
   const tools: ToolDefinition[] = [
-    createMemorySearchTool(engine, store, ctx),
+    createMemorySearchTool(engine, store, ctx, sharedState),
     createMemoryTimelineTool(store),
     createMemoryGetTool(store),
     createNetworkMemoryDetailTool(store, ctx),
@@ -84,7 +89,10 @@ export function initPlugin(opts: PluginInitOptions = {}): MemosLocalPlugin {
       const turnId = uuid();
       const tag = ctx.config.capture?.evidenceWrapperTag ?? "STORED_MEMORY";
 
-      const captured = captureMessages(messages, session, turnId, tag, ctx.log, owner);
+      const userSearchTime = sharedState.lastSearchTime || 0;
+      sharedState.lastSearchTime = 0;
+
+      const captured = captureMessages(messages, session, turnId, tag, ctx.log, owner, userSearchTime);
       if (captured.length > 0) {
         worker.enqueue(captured);
       }

package/src/ingest/chunker.ts

@@ -1,6 +1,8 @@
+export type ChunkKind = "paragraph" | "code_block" | "error_stack" | "list" | "command";
+
 export interface RawChunk {
   content: string;
-  kind: "paragraph";
+  kind: ChunkKind;
 }
 
 const MAX_CHUNK_CHARS = 3000;
@@ -28,21 +30,25 @@ const COMMAND_LINE_RE = /^(?:\$|>|#)\s+.+$/gm;
  */
 export function chunkText(text: string): RawChunk[] {
   let remaining = text;
-  const slots: Array<{ placeholder: string; content: string }> = [];
+  const slots: Array<{ placeholder: string; content: string; kind: ChunkKind }> = [];
   let counter = 0;
 
-  function ph(content: string): string {
+  function ph(content: string, kind: ChunkKind = "paragraph"): string {
     const tag = `\x00SLOT_${counter++}\x00`;
-    slots.push({ placeholder: tag, content: content.trim() });
+    slots.push({ placeholder: tag, content: content.trim(), kind });
     return tag;
   }
 
-  remaining = remaining.replace(FENCED_CODE_RE, (m) => ph(m));
+  remaining = remaining.replace(FENCED_CODE_RE, (m) => ph(m, "code_block"));
   remaining = extractBraceBlocks(remaining, ph);
 
-  const structural: RegExp[] = [ERROR_STACK_RE, LIST_BLOCK_RE, COMMAND_LINE_RE];
-  for (const re of structural) {
-    remaining = remaining.replace(re, (m) => ph(m));
+  const structuralKinds: Array<[RegExp, ChunkKind]> = [
+    [ERROR_STACK_RE, "error_stack"],
+    [LIST_BLOCK_RE, "list"],
+    [COMMAND_LINE_RE, "command"],
+  ];
+  for (const [re, kind] of structuralKinds) {
+    remaining = remaining.replace(re, (m) => ph(m, kind));
   }
 
   const raw: RawChunk[] = [];
@@ -57,7 +63,7 @@ export function chunkText(text: string): RawChunk[] {
       for (const part of parts) {
         const slot = slots.find((s) => s.placeholder === part);
         if (slot) {
-          raw.push({ content: slot.content, kind: "paragraph" });
+          raw.push({ content: slot.content, kind: slot.kind });
         } else if (part.trim().length >= MIN_CHUNK_CHARS) {
           raw.push({ content: part.trim(), kind: "paragraph" });
         }
@@ -69,7 +75,7 @@ export function chunkText(text: string): RawChunk[] {
 
   for (const s of slots) {
     if (!raw.some((c) => c.content === s.content)) {
-      raw.push({ content: s.content, kind: "paragraph" });
+      raw.push({ content: s.content, kind: s.kind });
     }
   }
 
@@ -85,7 +91,7 @@ export function chunkText(text: string): RawChunk[] {
  */
 function extractBraceBlocks(
   text: string,
-  ph: (content: string) => string,
+  ph: (content: string, kind?: ChunkKind) => string,
 ): string {
   const lines = text.split("\n");
   const result: string[] = [];
@@ -119,7 +125,7 @@ function extractBraceBlocks(
       if (depth <= 0 || (BLOCK_CLOSE_RE.test(line) && depth <= 0)) {
         const block = blockLines.join("\n");
         if (block.trim().length >= MIN_CHUNK_CHARS) {
-          result.push(ph(block));
+          result.push(ph(block, "code_block"));
         } else {
           result.push(block);
         }
@@ -135,7 +141,7 @@ function extractBraceBlocks(
   if (blockLines.length > 0) {
     const block = blockLines.join("\n");
     if (block.trim().length >= MIN_CHUNK_CHARS) {
-      result.push(ph(block));
+      result.push(ph(block, "code_block"));
     } else {
       result.push(block);
     }

package/src/ingest/providers/index.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { SummarizerConfig, Logger, OpenClawAPI } from "../../types";
+import type { SummarizerConfig, SummaryProvider, Logger, OpenClawAPI } from "../../types";
 import { summarizeOpenAI, summarizeTaskOpenAI, generateTaskTitleOpenAI, judgeNewTopicOpenAI, filterRelevantOpenAI, judgeDedupOpenAI, parseFilterResult, parseDedupResult } from "./openai";
 import type { FilterResult, DedupResult } from "./openai";
 export type { FilterResult, DedupResult } from "./openai";
@@ -8,6 +8,40 @@ import { summarizeAnthropic, summarizeTaskAnthropic, generateTaskTitleAnthropic,
 import { summarizeGemini, summarizeTaskGemini, generateTaskTitleGemini, judgeNewTopicGemini, filterRelevantGemini, judgeDedupGemini } from "./gemini";
 import { summarizeBedrock, summarizeTaskBedrock, generateTaskTitleBedrock, judgeNewTopicBedrock, filterRelevantBedrock, judgeDedupBedrock } from "./bedrock";
 
+/**
+ * Detect provider type from provider key name or base URL.
+ */
+function detectProvider(
+  providerKey: string | undefined,
+  baseUrl: string,
+): SummaryProvider {
+  const key = providerKey?.toLowerCase() ?? "";
+  const url = baseUrl.toLowerCase();
+  if (key.includes("anthropic") || url.includes("anthropic")) return "anthropic";
+  if (key.includes("gemini") || url.includes("generativelanguage.googleapis.com")) {
+    return "gemini";
+  }
+  if (key.includes("bedrock") || url.includes("bedrock")) return "bedrock";
+  return "openai_compatible";
+}
+
+/**
+ * Return the correct endpoint for a given provider and base URL.
+ */
+function normalizeEndpointForProvider(
+  provider: SummaryProvider,
+  baseUrl: string,
+): string {
+  const stripped = baseUrl.replace(/\/+$/, "");
+  if (provider === "anthropic") {
+    if (stripped.endsWith("/v1/messages")) return stripped;
+    return `${stripped}/v1/messages`;
+  }
+  if (stripped.endsWith("/chat/completions")) return stripped;
+  if (stripped.endsWith("/completions")) return stripped;
+  return `${stripped}/chat/completions`;
+}
+
 /**
  * Build a SummarizerConfig from OpenClaw's native model configuration (openclaw.json).
  * This serves as the final fallback when both strongCfg and plugin summarizer fail or are absent.
@@ -15,7 +49,8 @@ import { summarizeBedrock, summarizeTaskBedrock, generateTaskTitleBedrock, judge
 function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
   try {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const cfgPath = path.join(home, ".openclaw", "openclaw.json");
+    const cfgPath = process.env.OPENCLAW_CONFIG_PATH
+      || path.join(process.env.OPENCLAW_STATE_DIR || path.join(home, ".openclaw"), "openclaw.json");
     if (!fs.existsSync(cfgPath)) return undefined;
 
     const raw = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
@@ -36,13 +71,12 @@ function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
     const apiKey: string | undefined = providerCfg.apiKey;
     if (!baseUrl || !apiKey) return undefined;
 
-    const endpoint = baseUrl.endsWith("/chat/completions")
-      ? baseUrl
-      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
+    const provider = detectProvider(providerKey, baseUrl);
+    const endpoint = normalizeEndpointForProvider(provider, baseUrl);
 
-    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl} (${provider})`);
     return {
-      provider: "openai_compatible",
+      provider,
       endpoint,
       apiKey,
       model: modelId,

package/src/recall/engine.ts

@@ -74,10 +74,63 @@ export class RecallEngine {
       score: 1 / (i + 1),
     }));
 
+    // Step 1c: Hub memories search — only in Hub mode where local DB owns the
+    // hub_memories data and embeddings were generated by the same Embedder.
+    // Client mode must use remote API (hubSearchMemories) to avoid cross-model
+    // embedding mismatch.
+    let hubMemFtsRanked: Array<{ id: string; score: number }> = [];
+    let hubMemVecRanked: Array<{ id: string; score: number }> = [];
+    let hubMemPatternRanked: Array<{ id: string; score: number }> = [];
+    if (query && this.ctx.config.sharing?.enabled && this.ctx.config.sharing.role === "hub") {
+      try {
+        const hubFtsHits = this.store.searchHubMemories(query, { maxResults: candidatePool });
+        hubMemFtsRanked = hubFtsHits.map(({ hit }, i) => ({
+          id: `hubmem:${hit.id}`, score: 1 / (i + 1),
+        }));
+      } catch { /* hub_memories table may not exist */ }
+      if (shortTerms.length > 0) {
+        try {
+          const hubPatternHits = this.store.hubMemoryPatternSearch(shortTerms, { limit: candidatePool });
+          hubMemPatternRanked = hubPatternHits.map((h, i) => ({
+            id: `hubmem:${h.memoryId}`, score: 1 / (i + 1),
+          }));
+        } catch { /* best-effort */ }
+      }
+      try {
+        const hubMemEmbs = this.store.getVisibleHubMemoryEmbeddings("");
+        if (hubMemEmbs.length > 0) {
+          const qv = await this.embedder.embedQuery(query).catch(() => null);
+          if (qv) {
+            const scored: Array<{ id: string; score: number }> = [];
+            for (const e of hubMemEmbs) {
+              let dot = 0, nA = 0, nB = 0;
+              for (let i = 0; i < qv.length && i < e.vector.length; i++) {
+                dot += qv[i] * e.vector[i]; nA += qv[i] * qv[i]; nB += e.vector[i] * e.vector[i];
+              }
+              const sim = nA > 0 && nB > 0 ? dot / (Math.sqrt(nA) * Math.sqrt(nB)) : 0;
+              if (sim > 0.3) {
+                scored.push({ id: `hubmem:${e.memoryId}`, score: sim });
+              }
+            }
+            scored.sort((a, b) => b.score - a.score);
+            hubMemVecRanked = scored.slice(0, candidatePool);
+          }
+        }
+      } catch { /* best-effort */ }
+      const hubTotal = hubMemFtsRanked.length + hubMemVecRanked.length + hubMemPatternRanked.length;
+      if (hubTotal > 0) {
+        this.ctx.log.debug(`recall: hub_memories candidates: fts=${hubMemFtsRanked.length}, vec=${hubMemVecRanked.length}, pattern=${hubMemPatternRanked.length}`);
+      }
+    }
+
     // Step 2: RRF fusion
     const ftsRanked = ftsCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
     const vecRanked = vecCandidates.map((c) => ({ id: c.chunkId, score: c.score }));
-    const rrfScores = rrfFuse([ftsRanked, vecRanked, patternRanked], recallCfg.rrfK);
+    const allRankedLists = [ftsRanked, vecRanked, patternRanked];
+    if (hubMemFtsRanked.length > 0) allRankedLists.push(hubMemFtsRanked);
+    if (hubMemVecRanked.length > 0) allRankedLists.push(hubMemVecRanked);
+    if (hubMemPatternRanked.length > 0) allRankedLists.push(hubMemPatternRanked);
+    const rrfScores = rrfFuse(allRankedLists, recallCfg.rrfK);
 
     if (rrfScores.size === 0) {
       this.recordQuery(query, maxResults, minScore, 0);
@@ -101,6 +154,11 @@ export class RecallEngine {
 
     // Step 4: Time decay
     const withTs = mmrResults.map((r) => {
+      if (r.id.startsWith("hubmem:")) {
+        const memId = r.id.slice(7);
+        const mem = this.store.getHubMemoryById(memId);
+        return { ...r, createdAt: mem?.createdAt ?? 0 };
+      }
       const chunk = this.store.getChunk(r.id);
       return { ...r, createdAt: chunk?.createdAt ?? 0 };
     });
@@ -128,6 +186,35 @@ export class RecallEngine {
     const hits: SearchHit[] = [];
     for (const candidate of normalized) {
       if (hits.length >= maxResults) break;
+
+      if (candidate.id.startsWith("hubmem:")) {
+        const memId = candidate.id.slice(7);
+        const mem = this.store.getHubMemoryById(memId);
+        if (!mem) continue;
+        if (roleFilter && mem.role !== roleFilter) continue;
+        hits.push({
+          summary: mem.summary || mem.content.slice(0, 200),
+          original_excerpt: mem.content,
+          ref: {
+            sessionKey: `hub-shared:${mem.sourceUserId}`,
+            chunkId: mem.id,
+            turnId: "",
+            seq: 0,
+          },
+          score: Math.round(candidate.score * 1000) / 1000,
+          taskId: null,
+          skillId: null,
+          owner: `hub-user:${mem.sourceUserId}`,
+          origin: "hub-memory",
+          source: {
+            ts: mem.createdAt,
+            role: (mem.role || "assistant") as any,
+            sessionKey: `hub-shared:${mem.sourceUserId}`,
+          },
+        });
+        continue;
+      }
+
       const chunk = this.store.getChunk(candidate.id);
       if (!chunk) continue;
       if (roleFilter && chunk.role !== roleFilter) continue;
@@ -145,6 +232,7 @@ export class RecallEngine {
         score: Math.round(candidate.score * 1000) / 1000,
         taskId: chunk.taskId,
         skillId: chunk.skillId,
+        origin: chunk.owner === "public" ? "local-shared" : "local",
         source: {
           ts: chunk.createdAt,
           role: chunk.role,

package/src/shared/llm-call.ts

@@ -1,6 +1,34 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { SummarizerConfig, Logger, PluginContext, OpenClawAPI } from "../types";
+import type { SummarizerConfig, SummaryProvider, Logger, PluginContext, OpenClawAPI } from "../types";
+
+/**
+ * Detect provider type from provider key name or base URL.
+ */
+function detectProvider(providerKey: string | undefined, baseUrl: string): SummaryProvider {
+  const key = providerKey?.toLowerCase() ?? "";
+  const url = baseUrl.toLowerCase();
+  if (key.includes("anthropic") || url.includes("anthropic")) return "anthropic";
+  if (key.includes("gemini") || url.includes("generativelanguage.googleapis.com")) {
+    return "gemini";
+  }
+  if (key.includes("bedrock") || url.includes("bedrock")) return "bedrock";
+  return "openai_compatible";
+}
+
+/**
+ * Return the correct default endpoint for a given provider.
+ */
+function defaultEndpointForProvider(provider: SummaryProvider, baseUrl: string): string {
+  const stripped = baseUrl.replace(/\/+$/, "");
+  if (provider === "anthropic") {
+    if (stripped.endsWith("/v1/messages")) return stripped;
+    return `${stripped}/v1/messages`;
+  }
+  if (stripped.endsWith("/chat/completions")) return stripped;
+  if (stripped.endsWith("/completions")) return stripped;
+  return `${stripped}/chat/completions`;
+}
 
 /**
  * Build a SummarizerConfig from OpenClaw's native model configuration (openclaw.json).
@@ -9,7 +37,8 @@ import type { SummarizerConfig, Logger, PluginContext, OpenClawAPI } from "../ty
 export function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | undefined {
   try {
     const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
-    const cfgPath = path.join(home, ".openclaw", "openclaw.json");
+    const cfgPath = process.env.OPENCLAW_CONFIG_PATH
+      || path.join(process.env.OPENCLAW_STATE_DIR || path.join(home, ".openclaw"), "openclaw.json");
     if (!fs.existsSync(cfgPath)) return undefined;
 
     const raw = JSON.parse(fs.readFileSync(cfgPath, "utf-8"));
@@ -30,13 +59,12 @@ export function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | unde
     const apiKey: string | undefined = providerCfg.apiKey;
     if (!baseUrl || !apiKey) return undefined;
 
-    const endpoint = baseUrl.endsWith("/chat/completions")
-      ? baseUrl
-      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
+    const provider = detectProvider(providerKey, baseUrl);
+    const endpoint = defaultEndpointForProvider(provider, baseUrl);
 
-    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl} (${provider})`);
     return {
-      provider: "openai_compatible",
+      provider,
       endpoint,
       apiKey,
       model: modelId,
@@ -70,23 +98,34 @@ export interface LLMCallOptions {
   openclawAPI?: OpenClawAPI;
 }
 
-function normalizeEndpoint(url: string): string {
+function normalizeOpenAIEndpoint(url: string): string {
   const stripped = url.replace(/\/+$/, "");
   if (stripped.endsWith("/chat/completions")) return stripped;
   if (stripped.endsWith("/completions")) return stripped;
   return `${stripped}/chat/completions`;
 }
 
+function normalizeAnthropicEndpoint(url: string): string {
+  const stripped = url.replace(/\/+$/, "");
+  if (stripped.endsWith("/v1/messages")) return stripped;
+  if (stripped.endsWith("/messages")) return stripped;
+  return `${stripped}/v1/messages`;
+}
+
+function isAnthropicProvider(cfg: SummarizerConfig): boolean {
+  return cfg.provider === "anthropic";
+}
+
 /**
  * Make a single LLM call with the given config. Throws on failure.
  * When cfg.provider === "openclaw", delegates to the OpenClaw host completion API.
+ * Dispatches to Anthropic or OpenAI-compatible format based on provider.
  */
 export async function callLLMOnce(
   cfg: SummarizerConfig,
   prompt: string,
   opts: LLMCallOptions = {},
 ): Promise<string> {
-  // Handle openclaw provider via host completion API
   if (cfg.provider === "openclaw") {
     const api = opts.openclawAPI;
     if (!api) {
@@ -101,7 +140,57 @@ export async function callLLMOnce(
     return response.text.trim();
   }
 
-  const endpoint = normalizeEndpoint(cfg.endpoint ?? "https://api.openai.com/v1/chat/completions");
+  if (isAnthropicProvider(cfg)) {
+    return callLLMOnceAnthropic(cfg, prompt, opts);
+  }
+  return callLLMOnceOpenAI(cfg, prompt, opts);
+}
+
+async function callLLMOnceAnthropic(
+  cfg: SummarizerConfig,
+  prompt: string,
+  opts: LLMCallOptions = {},
+): Promise<string> {
+  const endpoint = normalizeAnthropicEndpoint(
+    cfg.endpoint ?? "https://api.anthropic.com/v1/messages",
+  );
+  const model = cfg.model ?? "claude-3-haiku-20240307";
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    "x-api-key": cfg.apiKey ?? "",
+    "anthropic-version": "2023-06-01",
+    ...cfg.headers,
+  };
+
+  const resp = await fetch(endpoint, {
+    method: "POST",
+    headers,
+    body: JSON.stringify({
+      model,
+      temperature: opts.temperature ?? 0.1,
+      max_tokens: opts.maxTokens ?? 1024,
+      messages: [{ role: "user", content: prompt }],
+    }),
+    signal: AbortSignal.timeout(opts.timeoutMs ?? 30_000),
+  });
+
+  if (!resp.ok) {
+    const body = await resp.text();
+    throw new Error(`LLM call failed (${resp.status}): ${body}`);
+  }
+
+  const json = (await resp.json()) as { content: Array<{ type: string; text: string }> };
+  return json.content.find((c) => c.type === "text")?.text?.trim() ?? "";
+}
+
+async function callLLMOnceOpenAI(
+  cfg: SummarizerConfig,
+  prompt: string,
+  opts: LLMCallOptions = {},
+): Promise<string> {
+  const endpoint = normalizeOpenAIEndpoint(
+    cfg.endpoint ?? "https://api.openai.com/v1/chat/completions",
+  );
   const model = cfg.model ?? "gpt-4o-mini";
   const headers: Record<string, string> = {
     "Content-Type": "application/json",

package/src/sharing/types.ts

@@ -12,7 +12,7 @@ import type {
 export type HubScope = "local" | "group" | "all";
 export type SharedVisibility = "group" | "public";
 export type UserRole = "admin" | "member";
-export type UserStatus = "pending" | "active" | "blocked" | "rejected";
+export type UserStatus = "pending" | "active" | "blocked" | "rejected" | "removed" | "left";
 
 export type { ClientModeConfig, HubModeConfig, SharingCapabilities, SharingConfig, SharingRole };