@memtensor/memos-local-openclaw-plugin 1.0.2 → 1.0.4-beta.0

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) => {
@@ -270,8 +270,8 @@ export class RecallEngine {
   ): Promise<number[]> {
     const candidateList = candidates.map((c, i) => ({
       index: i,
-      content: `[${c.skill.name}] ${c.skill.description}`,
       role: "skill" as const,
+      content: `[${c.skill.name}] ${c.skill.description}`,
     }));
 
     try {

package/src/shared/llm-call.ts

@@ -1,6 +1,6 @@
 import * as fs from "fs";
 import * as path from "path";
-import type { SummarizerConfig, Logger, PluginContext } from "../types";
+import type { SummarizerConfig, Logger, PluginContext, OpenClawAPI } from "../types";
 
 /**
  * Build a SummarizerConfig from OpenClaw's native model configuration (openclaw.json).
@@ -66,6 +66,8 @@ export interface LLMCallOptions {
   maxTokens?: number;
   temperature?: number;
   timeoutMs?: number;
+  /** Pass ctx.openclawAPI so callLLMOnce can handle provider === "openclaw" */
+  openclawAPI?: OpenClawAPI;
 }
 
 function normalizeEndpoint(url: string): string {
@@ -77,12 +79,28 @@ function normalizeEndpoint(url: string): string {
 
 /**
  * Make a single LLM call with the given config. Throws on failure.
+ * When cfg.provider === "openclaw", delegates to the OpenClaw host completion API.
  */
 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) {
+      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,
+      model: cfg.model,
+    });
+    return response.text.trim();
+  }
+
   const endpoint = normalizeEndpoint(cfg.endpoint ?? "https://api.openai.com/v1/chat/completions");
   const model = cfg.model ?? "gpt-4o-mini";
   const headers: Record<string, string> = {

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/generator.ts

@@ -356,7 +356,7 @@ export class SkillGenerator {
       .replace("{CONVERSATION}", conversationText.slice(0, 12000))
       + langInstruction;
 
-    const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillGenerator.step1", { maxTokens: 6000, temperature: 0.2, timeoutMs: 120_000 });
+    const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillGenerator.step1", { maxTokens: 6000, temperature: 0.2, timeoutMs: 120_000, openclawAPI: this.ctx.openclawAPI });
 
     const trimmed = raw.trim();
     if (trimmed.startsWith("---")) return trimmed;
@@ -379,7 +379,7 @@ export class SkillGenerator {
       .replace("{CONVERSATION}", conversationText.slice(0, 6000));
 
     try {
-      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillGenerator.scripts", { maxTokens: 3000, temperature: 0.1, timeoutMs: 120_000 });
+      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillGenerator.scripts", { maxTokens: 3000, temperature: 0.1, timeoutMs: 120_000, openclawAPI: this.ctx.openclawAPI });
       return this.parseJSONArray<{ filename: string; content: string }>(raw);
     } catch (err) {
       this.ctx.log.warn(`SkillGenerator: script extraction failed: ${err}`);
@@ -401,7 +401,7 @@ export class SkillGenerator {
       .replace("{CONVERSATION}", conversationText.slice(0, 6000));
 
     try {
-      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillGenerator.refs", { maxTokens: 3000, temperature: 0.1, timeoutMs: 120_000 });
+      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillGenerator.refs", { maxTokens: 3000, temperature: 0.1, timeoutMs: 120_000, openclawAPI: this.ctx.openclawAPI });
       return this.parseJSONArray<{ filename: string; content: string }>(raw);
     } catch (err) {
       this.ctx.log.warn(`SkillGenerator: reference extraction failed: ${err}`);
@@ -423,7 +423,7 @@ export class SkillGenerator {
       + `\n\n⚠️ LANGUAGE: Write test prompts and expectations in ${lang}, matching the skill's language.\n`;
 
     try {
-      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillGenerator.evals", { maxTokens: 2000, temperature: 0.3, timeoutMs: 120_000 });
+      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillGenerator.evals", { maxTokens: 2000, temperature: 0.3, timeoutMs: 120_000, openclawAPI: this.ctx.openclawAPI });
       return this.parseJSONArray(raw);
     } catch (err) {
       this.ctx.log.warn(`SkillGenerator: eval generation failed: ${err}`);
@@ -467,6 +467,7 @@ export class SkillGenerator {
     return { hitCount, results };
   }
 
+
   // ─── Helpers ───
 
   private parseJSONArray<T>(raw: string): T[] {
@@ -499,4 +500,5 @@ export class SkillGenerator {
     return "";
   }
 
+
 }

package/src/skill/upgrader.ts

@@ -190,7 +190,7 @@ export class SkillUpgrader {
       .replace("{TASK_ID}", task.id)
       + langInstruction;
 
-    const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillUpgrader.upgrade", { maxTokens: 6000, temperature: 0.2, timeoutMs: 90_000 });
+    const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillUpgrader.upgrade", { maxTokens: 6000, temperature: 0.2, timeoutMs: 90_000, openclawAPI: this.ctx.openclawAPI });
 
     const changelogSep = raw.indexOf("---CHANGELOG---");
     if (changelogSep !== -1) {

package/src/skill/validator.ts

@@ -143,7 +143,7 @@ export class SkillValidator {
     const prompt = QUALITY_PROMPT.replace("{SKILL_CONTENT}", content.slice(0, 6000));
 
     try {
-      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillValidator.quality");
+      const raw = await callLLMWithFallback(chain, prompt, this.ctx.log, "SkillValidator.quality", { openclawAPI: this.ctx.openclawAPI });
 
       const jsonMatch = raw.match(/\{[\s\S]*\}/);
       if (!jsonMatch) return;