@memtensor/memos-local-openclaw-plugin 1.0.4-beta.6 → 1.0.4-beta.7

package/src/openclaw-api.ts

@@ -0,0 +1,287 @@
+/**
+ * OpenClaw Host Model Proxy
+ *
+ * Reads the host's configured model providers (api.config.models.providers)
+ * and proxies completion / embedding requests via OpenAI-compatible HTTP calls.
+ */
+
+import type { Logger, OpenClawAPI } from "./types";
+
+// ── Request / Response types ────────────────────────────────────────
+
+export interface OpenClawEmbedRequest {
+  texts: string[];
+  model?: string;
+}
+
+export interface OpenClawEmbedResponse {
+  embeddings: number[][];
+  dimensions: number;
+}
+
+export interface OpenClawCompleteRequest {
+  prompt: string;
+  maxTokens?: number;
+  temperature?: number;
+  model?: string;
+}
+
+export interface OpenClawCompleteResponse {
+  text: string;
+}
+
+// ── Host model config (mirrors OpenClaw SDK types loosely) ──────────
+
+export interface HostModelDefinition {
+  id: string;
+  name: string;
+  api?: string;
+  [key: string]: unknown;
+}
+
+export interface HostModelProvider {
+  baseUrl: string;
+  apiKey?: string | { source: string; provider: string; id: string };
+  api?: string;
+  headers?: Record<string, string>;
+  models: HostModelDefinition[];
+}
+
+export interface HostModelsConfig {
+  providers?: Record<string, HostModelProvider>;
+}
+
+// ── Resolved provider info (internal) ───────────────────────────────
+
+interface ResolvedProvider {
+  name: string;
+  baseUrl: string;
+  apiKey?: string;
+  api?: string;
+  headers?: Record<string, string>;
+  model: string;
+}
+
+// ── Client ──────────────────────────────────────────────────────────
+
+export class OpenClawAPIClient implements OpenClawAPI {
+  private completionProvider: ResolvedProvider | undefined;
+  private embeddingProvider: ResolvedProvider | undefined;
+
+  constructor(
+    private log: Logger,
+    hostModels?: HostModelsConfig,
+  ) {
+    if (hostModels?.providers) {
+      this.completionProvider = pickCompletionProvider(hostModels.providers, log);
+      this.embeddingProvider = pickEmbeddingProvider(hostModels.providers, log);
+    }
+  }
+
+  // ── Embedding ─────────────────────────────────────────────────────
+
+  async embed(request: OpenClawEmbedRequest): Promise<OpenClawEmbedResponse> {
+    const provider = this.embeddingProvider;
+    if (!provider) {
+      throw new Error(
+        "No host embedding provider available. " +
+        "Configure a model provider with an embedding model in OpenClaw, " +
+        "or use an explicit embedding provider (openai, gemini, cohere, etc.)."
+      );
+    }
+
+    const model = request.model ?? provider.model;
+    const endpoint = normalizeEndpoint(provider.baseUrl, "/embeddings");
+
+    this.log.debug(`OpenClawAPI.embed → ${provider.name} (${model}) [${request.texts.length} texts]`);
+
+    const resp = await fetch(endpoint, {
+      method: "POST",
+      headers: buildHeaders(provider),
+      body: JSON.stringify({ input: request.texts, model }),
+      signal: AbortSignal.timeout(30_000),
+    });
+
+    if (!resp.ok) {
+      const body = await resp.text();
+      throw new Error(`Host embedding failed (${provider.name} ${resp.status}): ${body}`);
+    }
+
+    const json = (await resp.json()) as {
+      data: Array<{ embedding: number[] }>;
+    };
+
+    const embeddings = json.data.map((d) => d.embedding);
+    const dimensions = embeddings[0]?.length ?? 0;
+
+    this.log.debug(`OpenClawAPI.embed ← ${embeddings.length} vectors, dim=${dimensions}`);
+    return { embeddings, dimensions };
+  }
+
+  // ── Completion ────────────────────────────────────────────────────
+
+  async complete(request: OpenClawCompleteRequest): Promise<OpenClawCompleteResponse> {
+    const provider = this.completionProvider;
+    if (!provider) {
+      throw new Error(
+        "No host completion provider available. " +
+        "Configure a model provider in OpenClaw, " +
+        "or use an explicit summarizer provider (openai, anthropic, gemini, etc.)."
+      );
+    }
+
+    const model = request.model ?? provider.model;
+    const endpoint = normalizeEndpoint(provider.baseUrl, "/chat/completions");
+
+    this.log.debug(`OpenClawAPI.complete → ${provider.name} (${model})`);
+
+    const body: Record<string, unknown> = {
+      model,
+      messages: [{ role: "user", content: request.prompt }],
+      temperature: request.temperature ?? 0,
+    };
+    if (request.maxTokens) {
+      body.max_tokens = request.maxTokens;
+    }
+
+    const resp = await fetch(endpoint, {
+      method: "POST",
+      headers: buildHeaders(provider),
+      body: JSON.stringify(body),
+      signal: AbortSignal.timeout(60_000),
+    });
+
+    if (!resp.ok) {
+      const respBody = await resp.text();
+      throw new Error(`Host completion failed (${provider.name} ${resp.status}): ${respBody}`);
+    }
+
+    const json = (await resp.json()) as {
+      choices: Array<{ message: { content: string } }>;
+    };
+
+    const text = json.choices?.[0]?.message?.content ?? "";
+    this.log.debug(`OpenClawAPI.complete ← ${text.length} chars`);
+    return { text };
+  }
+}
+
+// ── Helpers ─────────────────────────────────────────────────────────
+
+/**
+ * Resolve a SecretInput (string | SecretRef) to a plain string.
+ * For env-sourced SecretRef, reads from process.env.
+ * Other sources are not supported — returns undefined.
+ */
+function resolveApiKey(
+  input: string | { source: string; provider: string; id: string } | undefined,
+): string | undefined {
+  if (!input) return undefined;
+  if (typeof input === "string") return input;
+  // SecretRef — only env source is supported in plugin context
+  if (input.source === "env") return process.env[input.id];
+  return undefined;
+}
+
+function buildHeaders(provider: ResolvedProvider): Record<string, string> {
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+    ...provider.headers,
+  };
+  if (provider.apiKey) {
+    headers["Authorization"] = `Bearer ${provider.apiKey}`;
+  }
+  return headers;
+}
+
+/**
+ * Normalize base URL + path suffix.
+ * e.g. "https://api.openai.com/v1" + "/chat/completions"
+ *   → "https://api.openai.com/v1/chat/completions"
+ */
+function normalizeEndpoint(baseUrl: string, suffix: string): string {
+  const base = baseUrl.replace(/\/+$/, "");
+  // If baseUrl already ends with the suffix, don't double-append
+  if (base.endsWith(suffix)) return base;
+  return `${base}${suffix}`;
+}
+
+/**
+ * Pick the best provider for chat completions.
+ * Priority: openai-completions API > has apiKey > first with models.
+ */
+function pickCompletionProvider(
+  providers: Record<string, HostModelProvider>,
+  log: Logger,
+): ResolvedProvider | undefined {
+  const entries = Object.entries(providers).filter(([, p]) => p.models?.length > 0);
+  if (entries.length === 0) return undefined;
+
+  // Sort: prefer openai-completions api, then providers with apiKey
+  entries.sort(([, a], [, b]) => {
+    const aScore = (a.api === "openai-completions" ? 2 : 0) + (resolveApiKey(a.apiKey) ? 1 : 0);
+    const bScore = (b.api === "openai-completions" ? 2 : 0) + (resolveApiKey(b.apiKey) ? 1 : 0);
+    return bScore - aScore;
+  });
+
+  const [name, provider] = entries[0];
+  const model = provider.models[0].id;
+  log.info(`Host completion provider: ${name} → ${model}`);
+
+  return {
+    name,
+    baseUrl: provider.baseUrl,
+    apiKey: resolveApiKey(provider.apiKey),
+    api: provider.api,
+    headers: provider.headers,
+    model,
+  };
+}
+
+/**
+ * Pick the best provider for embeddings.
+ * Priority: model name contains "embed" > first provider with apiKey.
+ */
+function pickEmbeddingProvider(
+  providers: Record<string, HostModelProvider>,
+  log: Logger,
+): ResolvedProvider | undefined {
+  const entries = Object.entries(providers).filter(([, p]) => p.models?.length > 0);
+  if (entries.length === 0) return undefined;
+
+  // Try to find a provider that has an embedding model
+  for (const [name, provider] of entries) {
+    const embedModel = provider.models.find((m) =>
+      m.id.toLowerCase().includes("embed") || m.name.toLowerCase().includes("embed"),
+    );
+    if (embedModel) {
+      log.info(`Host embedding provider: ${name} → ${embedModel.id}`);
+      return {
+        name,
+        baseUrl: provider.baseUrl,
+        apiKey: resolveApiKey(provider.apiKey),
+        api: provider.api,
+        headers: provider.headers,
+        model: embedModel.id,
+      };
+    }
+  }
+
+  // Fallback: use first provider with apiKey, pick first model
+  const withKey = entries.find(([, p]) => !!resolveApiKey(p.apiKey));
+  if (withKey) {
+    const [name, provider] = withKey;
+    const model = provider.models[0].id;
+    log.info(`Host embedding provider (fallback): ${name} → ${model}`);
+    return {
+      name,
+      baseUrl: provider.baseUrl,
+      apiKey: resolveApiKey(provider.apiKey),
+      api: provider.api,
+      headers: provider.headers,
+      model,
+    };
+  }
+
+  return undefined;
+}

package/src/recall/engine.ts

@@ -246,7 +246,7 @@ export class RecallEngine {
     if (candidateSkills.length === 0) return [];
 
     // LLM relevance judgment
-    const summarizer = new Summarizer(this.ctx.config.summarizer, this.ctx.log);
+    const summarizer = new Summarizer(this.ctx.config.summarizer, this.ctx.log, this.ctx.openclawAPI);
     const relevantIndices = await this.judgeSkillRelevance(summarizer, query, candidateSkills);
 
     return relevantIndices.map((idx) => {

package/src/shared/llm-call.ts

@@ -1,35 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { SummarizerConfig, SummaryProvider, Logger, PluginContext } 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`;
-  }
-  // OpenAI-compatible providers
-  if (stripped.endsWith("/chat/completions")) return stripped;
-  if (stripped.endsWith("/completions")) return stripped;
-  return `${stripped}/chat/completions`;
-}
+import type { SummarizerConfig, Logger, PluginContext, OpenClawAPI } from "../types";
 
 /**
  * Build a SummarizerConfig from OpenClaw's native model configuration (openclaw.json).
@@ -59,12 +30,13 @@ export function loadOpenClawFallbackConfig(log: Logger): SummarizerConfig | unde
     const apiKey: string | undefined = providerCfg.apiKey;
     if (!baseUrl || !apiKey) return undefined;
 
-    const provider = detectProvider(providerKey, baseUrl);
-    const endpoint = defaultEndpointForProvider(provider, baseUrl);
+    const endpoint = baseUrl.endsWith("/chat/completions")
+      ? baseUrl
+      : baseUrl.replace(/\/+$/, "") + "/chat/completions";
 
-    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl} (${provider})`);
+    log.debug(`OpenClaw fallback model: ${modelId} via ${baseUrl}`);
     return {
-      provider,
+      provider: "openai_compatible",
       endpoint,
       apiKey,
       model: modelId,
@@ -94,86 +66,42 @@ export interface LLMCallOptions {
   maxTokens?: number;
   temperature?: number;
   timeoutMs?: number;
+  /** Pass ctx.openclawAPI so callLLMOnce can handle provider === "openclaw" */
+  openclawAPI?: OpenClawAPI;
 }
 
-function normalizeOpenAIEndpoint(url: string): string {
+function normalizeEndpoint(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.
- * Dispatches to Anthropic or OpenAI-compatible format based on provider.
+ * When cfg.provider === "openclaw", delegates to the OpenClaw host completion API.
  */
 export async function callLLMOnce(
   cfg: SummarizerConfig,
   prompt: string,
   opts: LLMCallOptions = {},
 ): Promise<string> {
-  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,
+  // Handle openclaw provider via host completion API
+  if (cfg.provider === "openclaw") {
+    const api = opts.openclawAPI;
+    if (!api) {
+      throw new Error("OpenClaw API not available. Ensure sharing.capabilities.hostCompletion is enabled.");
+    }
+    const response = await api.complete({
+      prompt,
+      maxTokens: opts.maxTokens ?? 1024,
       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}`);
+      model: cfg.model,
+    });
+    return response.text.trim();
   }
 
-  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 endpoint = normalizeEndpoint(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.contract.ts

@@ -0,0 +1,40 @@
+import type {
+  ClientModeConfig as RootClientModeConfig,
+  HubModeConfig as RootHubModeConfig,
+  SharingCapabilities as RootSharingCapabilities,
+  SharingConfig as RootSharingConfig,
+  SharingRole as RootSharingRole,
+} from "../types";
+import type {
+  ClientModeConfig as SharingClientModeConfig,
+  GroupInfo,
+  HubModeConfig as SharingHubModeConfig,
+  HubSearchHit,
+  NetworkSearchResult,
+  SharingCapabilities as SharingSharingCapabilities,
+  SharingConfig as SharingSharingConfig,
+  SharingRole as SharingSharingRole,
+  SkillBundle,
+  UserInfo,
+} from "./types";
+
+type Assert<T extends true> = T;
+type Equal<A, B> =
+  (<T>() => T extends A ? 1 : 2) extends (<T>() => T extends B ? 1 : 2)
+    ? ((<T>() => T extends B ? 1 : 2) extends (<T>() => T extends A ? 1 : 2) ? true : false)
+    : false;
+type Extends<A, B> = A extends B ? true : false;
+
+type _SharingRoleMatchesRoot = Assert<Equal<SharingSharingRole, RootSharingRole>>;
+type _SharingCapabilitiesMatchRoot = Assert<Equal<SharingSharingCapabilities, RootSharingCapabilities>>;
+type _HubModeConfigMatchesRoot = Assert<Equal<SharingHubModeConfig, RootHubModeConfig>>;
+type _ClientModeConfigMatchesRoot = Assert<Equal<SharingClientModeConfig, RootClientModeConfig>>;
+type _SharingConfigMatchesRoot = Assert<Equal<SharingSharingConfig, RootSharingConfig>>;
+
+type _GroupInfoExists = Assert<Extends<GroupInfo, { id: string; name: string }>>;
+type _UserInfoExists = Assert<Extends<UserInfo, { id: string; username: string }>>;
+type _HubSearchHitExists = Assert<Extends<HubSearchHit, { remoteHitId: string; hubRank: number }>>;
+type _NetworkSearchResultExists = Assert<Extends<NetworkSearchResult, { local: unknown; hub: unknown }>>;
+type _SkillBundleExists = Assert<Extends<SkillBundle, { metadata: unknown; bundle: unknown }>>;
+
+export {};

package/src/sharing/types.ts

@@ -0,0 +1,102 @@
+import type {
+  ClientModeConfig,
+  HubModeConfig,
+  Role,
+  SearchResult,
+  SharingCapabilities,
+  SharingConfig,
+  SharingRole,
+  SkillGenerateOutput,
+} from "../types";
+
+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 { ClientModeConfig, HubModeConfig, SharingCapabilities, SharingConfig, SharingRole };
+
+export interface GroupInfo {
+  id: string;
+  name: string;
+  description?: string;
+}
+
+export interface UserInfo {
+  id: string;
+  username: string;
+  deviceName?: string;
+  role: UserRole;
+  status: UserStatus;
+  groups: GroupInfo[];
+}
+
+export interface HubSearchHit {
+  remoteHitId: string;
+  summary: string;
+  excerpt: string;
+  hubRank: number;
+  taskTitle: string | null;
+  ownerName: string;
+  groupName: string | null;
+  visibility: SharedVisibility;
+  source: {
+    ts: number;
+    role: Role;
+  };
+}
+
+export interface HubSearchMeta {
+  totalCandidates: number;
+  searchedGroups: string[];
+  includedPublic: boolean;
+}
+
+export interface HubSearchResult {
+  hits: HubSearchHit[];
+  meta: HubSearchMeta;
+}
+
+export interface HubMemoryDetail {
+  remoteHitId: string;
+  content: string;
+  summary: string;
+  source: {
+    ts: number;
+    role: Role;
+  };
+}
+
+export interface HubSkillHit {
+  skillId: string;
+  name: string;
+  description: string;
+  version: number;
+  visibility: SharedVisibility;
+  groupName: string | null;
+  ownerName: string;
+  qualityScore: number | null;
+}
+
+export interface HubSkillSearchResult {
+  hits: HubSkillHit[];
+}
+
+export interface NetworkSearchResult {
+  local: SearchResult;
+  hub: HubSearchResult;
+}
+
+export interface SkillBundleMetadata {
+  id: string;
+  name: string;
+  description: string;
+  version: number;
+  qualityScore: number | null;
+}
+
+export interface SkillBundle {
+  metadata: SkillBundleMetadata;
+  bundle: SkillGenerateOutput;
+}
+

package/src/skill/evaluator.ts

@@ -145,7 +145,7 @@ export class SkillEvaluator {
       .replace("{SUMMARY}", task.summary.slice(0, 3000));
 
     try {
-      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillEvaluator.create");
+      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillEvaluator.create", { openclawAPI: this.ctx.openclawAPI });
       return this.parseJSON<CreateEvalResult>(raw, {
         shouldGenerate: false, reason: "parse failed", suggestedName: "", suggestedTags: [], confidence: 0,
       });
@@ -169,7 +169,7 @@ export class SkillEvaluator {
       .replace("{SUMMARY}", task.summary.slice(0, 3000));
 
     try {
-      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillEvaluator.upgrade");
+      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillEvaluator.upgrade", { openclawAPI: this.ctx.openclawAPI });
       return this.parseJSON<UpgradeEvalResult>(raw, {
         shouldUpgrade: false, upgradeType: "refine", dimensions: [], reason: "parse failed", mergeStrategy: "", confidence: 0,
       });
@@ -179,6 +179,7 @@ export class SkillEvaluator {
     }
   }
 
+
   private parseJSON<T>(raw: string, fallback: T): T {
     const jsonMatch = raw.match(/\{[\s\S]*\}/);
     if (!jsonMatch) return fallback;

package/src/skill/evolver.ts

@@ -12,8 +12,6 @@ import { SkillUpgrader } from "./upgrader";
 import { SkillInstaller } from "./installer";
 import { buildSkillConfigChain, callLLMWithFallback } from "../shared/llm-call";
 
-export type SkillEvolvedCallback = (skillName: string, upgradeType: "created" | "upgraded") => void;
-
 export class SkillEvolver {
   private evaluator: SkillEvaluator;
   private generator: SkillGenerator;
@@ -21,7 +19,6 @@ export class SkillEvolver {
   private installer: SkillInstaller;
   private processing = false;
   private queue: Task[] = [];
-  onSkillEvolved: SkillEvolvedCallback | null = null;
 
   constructor(
     private store: SqliteStore,
@@ -282,7 +279,6 @@ Use selectedIndex 0 when none is highly relevant.`;
       if (upgraded) {
         this.store.linkTaskSkill(task.id, freshSkill.id, "evolved_from", freshSkill.version + 1);
         this.installer.syncIfInstalled(freshSkill.name);
-        this.onSkillEvolved?.(freshSkill.name, "upgraded");
       } else {
         this.store.linkTaskSkill(task.id, freshSkill.id, "applied_to", freshSkill.version);
       }
@@ -311,7 +307,6 @@ Use selectedIndex 0 when none is highly relevant.`;
       this.markChunksWithSkill(chunks, skill.id);
       this.store.linkTaskSkill(task.id, skill.id, "generated_from", 1);
       this.store.setTaskSkillMeta(task.id, { skillStatus: "generated", skillReason: evalResult.reason });
-      this.onSkillEvolved?.(skill.name, "created");
 
       const autoInstall = this.ctx.config.skillEvolution?.autoInstall ?? DEFAULTS.skillAutoInstall;
       if (autoInstall && skill.status === "active") {