@allbaseai/openclaw-allbase 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Allbase
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# OpenClaw Allbase Plugin
+
+Connect OpenClaw agents to Allbase profiles (workspace/agent/api key), with per-agent mapping.
+
+## What it supports
+
+- Map each OpenClaw agent to a different Allbase profile
+- Or map all OpenClaw agents to the same Allbase profile
+- Tools exposed in agent runtime:
+  - `allbase` with actions:
+    - `status`
+    - `save_memory`
+    - `save_knowledge`
+    - `search_memories`
+    - `upload_document`
+    - `search_documents`
+
+## Install (npm)
+
+```bash
+openclaw plugins install @allbase/openclaw-allbase
+```
+
+## Install (local path)
+
+```bash
+cd /home/jason/Documents/botscripts/skills/openclaw-allbase-plugin
+npm install
+openclaw plugins install -l /home/jason/Documents/botscripts/skills/openclaw-allbase-plugin
+```
+
+Then restart gateway.
+
+## Config example
+
+Put this under `plugins.entries.allbase.config`:
+
+```json5
+{
+  baseUrl: "https://allbase.ai",
+  tokenPath: "/token",
+  defaultProfile: "team",
+  profiles: {
+    team: {
+      workspaceId: "ws-TEAM",
+      agentId: "team-agent",
+      apiKey: "abk_..."
+    },
+    personal: {
+      workspaceId: "ws-PERSONAL",
+      agentId: "jason-agent",
+      apiKey: "abk_..."
+    }
+  },
+  mapByOpenclawAgent: {
+    "alan-allbase": "team",
+    "assistant-personal": "personal"
+  }
+}
+```
+
+## Usage examples
+
+- Check mapping/health:
+  - tool call: `allbase` with `action: "status"`
+- Save memory:
+  - `action: "save_memory"`, `content`, optional `category`, `tags`
+- Search memory:
+  - `action: "search_memories"`, `query`
+
+Optional `profile` parameter overrides automatic mapping for one call.
+
+## Notes
+
+- Keep API keys private.
+- If token exchange fails, verify workspace_id + agent_id + api_key belong together.
+- `upload_document` requires local file path available to the gateway host.

package/index.ts

@@ -0,0 +1,350 @@
+import { Type } from "@sinclair/typebox";
+import type { AnyAgentTool, OpenClawPluginApi, OpenClawPluginToolContext } from "openclaw/plugin-sdk";
+import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
+import { readFileSync } from "node:fs";
+import { basename } from "node:path";
+
+type AgentResult = { content: Array<{ type: string; text: string }>; details?: unknown };
+
+type AllbaseProfile = {
+  workspaceId: string;
+  agentId: string;
+  apiKey: string;
+  baseUrl?: string;
+};
+
+type AllbasePluginConfig = {
+  baseUrl?: string;
+  tokenPath?: string;
+  defaultProfile?: string;
+  profiles?: Record<string, AllbaseProfile>;
+  mapByOpenclawAgent?: Record<string, string>;
+};
+
+const TOOL_ACTIONS = [
+  "status",
+  "save_memory",
+  "save_knowledge",
+  "search_memories",
+  "upload_document",
+  "search_documents",
+] as const;
+
+const AllbaseToolSchema = Type.Object(
+  {
+    action: Type.Unsafe<(typeof TOOL_ACTIONS)[number]>({ type: "string", enum: [...TOOL_ACTIONS] }),
+    profile: Type.Optional(Type.String({ description: "Optional profile override" })),
+
+    content: Type.Optional(Type.String({ description: "Memory content" })),
+    category: Type.Optional(Type.String({ description: "decision|research|preference|plan|knowledge" })),
+    tags: Type.Optional(Type.String({ description: "Comma-separated tags" })),
+    visibility: Type.Optional(Type.String({ description: "private|public" })),
+
+    query: Type.Optional(Type.String({ description: "Search query" })),
+    limit: Type.Optional(Type.Number({ minimum: 1, maximum: 50 })),
+    scope: Type.Optional(Type.String({ description: "private|public|all" })),
+    tag: Type.Optional(Type.String({ description: "Single tag filter" })),
+
+    filePath: Type.Optional(Type.String({ description: "Local file path to upload" })),
+    title: Type.Optional(Type.String({ description: "Optional document title" }))
+  },
+  { additionalProperties: false },
+);
+
+const tokenCache = new Map<string, { token: string; exp: number }>();
+
+function json(payload: unknown): AgentResult {
+  return {
+    content: [{ type: "text", text: JSON.stringify(payload, null, 2) }],
+    details: payload,
+  };
+}
+
+function parseTags(tags?: string): string[] {
+  if (!tags) return [];
+  return tags
+    .split(",")
+    .map((x) => x.trim())
+    .filter(Boolean);
+}
+
+function getConfig(api: OpenClawPluginApi): AllbasePluginConfig {
+  return (api.pluginConfig ?? {}) as AllbasePluginConfig;
+}
+
+function resolveBaseUrl(cfg: AllbasePluginConfig, profile?: AllbaseProfile): string {
+  const base = (profile?.baseUrl || cfg.baseUrl || "https://allbase.ai").trim();
+  return base.replace(/\/+$/, "");
+}
+
+function resolveProfile(
+  api: OpenClawPluginApi,
+  ctx: OpenClawPluginToolContext,
+  profileOverride?: string,
+): { profileName: string; profile: AllbaseProfile; baseUrl: string; tokenPath: string } {
+  const cfg = getConfig(api);
+  const profiles = cfg.profiles ?? {};
+
+  const selectedName =
+    (profileOverride && profileOverride.trim()) ||
+    (ctx.agentId ? cfg.mapByOpenclawAgent?.[ctx.agentId] : undefined) ||
+    cfg.defaultProfile ||
+    Object.keys(profiles)[0];
+
+  if (!selectedName) {
+    throw new Error(
+      "No Allbase profile resolved. Configure plugins.entries.allbase.config.profiles and defaultProfile.",
+    );
+  }
+
+  const profile = profiles[selectedName];
+  if (!profile) {
+    throw new Error(`Configured profile not found: ${selectedName}`);
+  }
+
+  if (!profile.workspaceId || !profile.agentId || !profile.apiKey) {
+    throw new Error(`Profile ${selectedName} is missing workspaceId/agentId/apiKey`);
+  }
+
+  const baseUrl = resolveBaseUrl(cfg, profile);
+  const tokenPath = (cfg.tokenPath || "/token").trim() || "/token";
+
+  return { profileName: selectedName, profile, baseUrl, tokenPath };
+}
+
+async function getAccessToken(
+  api: OpenClawPluginApi,
+  ctx: OpenClawPluginToolContext,
+  profileOverride?: string,
+): Promise<{ token: string; resolved: ReturnType<typeof resolveProfile> }> {
+  const resolved = resolveProfile(api, ctx, profileOverride);
+  const { profile, baseUrl, tokenPath } = resolved;
+  const cacheKey = `${baseUrl}|${profile.workspaceId}|${profile.agentId}|${profile.apiKey}`;
+  const now = Date.now();
+  const cached = tokenCache.get(cacheKey);
+  if (cached && cached.exp > now + 30_000) {
+    return { token: cached.token, resolved };
+  }
+
+  const url = new URL(`${baseUrl}${tokenPath}`);
+  url.searchParams.set("workspace_id", profile.workspaceId);
+  url.searchParams.set("agent_id", profile.agentId);
+  url.searchParams.set("api_key", profile.apiKey);
+
+  const response = await fetch(url, { method: "POST" });
+  if (!response.ok) {
+    throw new Error(`Token exchange failed (${response.status}): ${await response.text()}`);
+  }
+  const data = (await response.json()) as { access_token?: string; expires_in?: number };
+  if (!data.access_token) {
+    throw new Error("Token exchange did not return access_token");
+  }
+
+  const ttlMs = Math.max(60_000, (data.expires_in ?? 3600) * 1000);
+  tokenCache.set(cacheKey, { token: data.access_token, exp: now + ttlMs });
+  return { token: data.access_token, resolved };
+}
+
+async function callAllbase(
+  api: OpenClawPluginApi,
+  ctx: OpenClawPluginToolContext,
+  profileOverride: string | undefined,
+  path: string,
+  init: RequestInit,
+) {
+  const { token, resolved } = await getAccessToken(api, ctx, profileOverride);
+  const response = await fetch(`${resolved.baseUrl}${path}`, {
+    ...init,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      ...(init.headers || {}),
+    },
+  });
+
+  const text = await response.text();
+  let body: unknown = text;
+  try {
+    body = text ? JSON.parse(text) : {};
+  } catch {
+    // keep text body
+  }
+
+  return { ok: response.ok, status: response.status, body, resolved };
+}
+
+async function executeAllbaseTool(
+  api: OpenClawPluginApi,
+  ctx: OpenClawPluginToolContext,
+  _toolCallId: string,
+  params: {
+    action: (typeof TOOL_ACTIONS)[number];
+    profile?: string;
+    content?: string;
+    category?: string;
+    tags?: string;
+    visibility?: string;
+    query?: string;
+    limit?: number;
+    scope?: string;
+    tag?: string;
+    filePath?: string;
+    title?: string;
+  },
+): Promise<AgentResult> {
+  try {
+    const action = params.action;
+    const profileOverride = params.profile?.trim();
+
+    if (action === "status") {
+      const cfg = getConfig(api);
+      const resolved = resolveProfile(api, ctx, profileOverride);
+      const healthResp = await fetch(`${resolveBaseUrl(cfg, resolved.profile)}/healthz`);
+      const health = await healthResp.json().catch(() => ({}));
+      return json({
+        ok: true,
+        profile: resolved.profileName,
+        openclawAgentId: ctx.agentId || null,
+        workspaceId: resolved.profile.workspaceId,
+        allbaseAgentId: resolved.profile.agentId,
+        baseUrl: resolved.baseUrl,
+        health,
+      });
+    }
+
+    if (action === "save_memory" || action === "save_knowledge") {
+      const content = (params.content || "").trim();
+      if (!content) throw new Error("content is required");
+
+      const payload = {
+        content,
+        category: action === "save_knowledge" ? "knowledge" : (params.category || "knowledge"),
+        tags: parseTags(params.tags),
+        visibility: params.visibility === "public" ? "public" : "private",
+        is_verified: false,
+        metadata: { source: "openclaw-plugin", plugin: "allbase" },
+      };
+
+      const result = await callAllbase(api, ctx, profileOverride, "/memories", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+
+      return json(result);
+    }
+
+    if (action === "search_memories") {
+      const query = (params.query || "").trim();
+      if (!query) throw new Error("query is required");
+
+      const payload = {
+        query,
+        limit: Math.max(1, Math.min(50, Number(params.limit || 8))),
+        scope: params.scope === "public" || params.scope === "all" ? params.scope : "private",
+        ...(params.category ? { category: params.category } : {}),
+        ...(params.tag ? { tag: params.tag } : {}),
+        search_mode: "hybrid",
+      };
+
+      const result = await callAllbase(api, ctx, profileOverride, "/memories/search", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+
+      return json(result);
+    }
+
+    if (action === "search_documents") {
+      const query = (params.query || "").trim();
+      if (!query) throw new Error("query is required");
+      const payload = {
+        query,
+        limit: Math.max(1, Math.min(50, Number(params.limit || 8))),
+      };
+      const result = await callAllbase(api, ctx, profileOverride, "/documents/search", {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      });
+      return json(result);
+    }
+
+    if (action === "upload_document") {
+      const filePath = (params.filePath || "").trim();
+      if (!filePath) throw new Error("filePath is required");
+
+      const fileData = readFileSync(filePath);
+      const form = new FormData();
+      form.append("file", new Blob([fileData]), basename(filePath));
+      if (params.title?.trim()) form.append("title", params.title.trim());
+
+      const { token, resolved } = await getAccessToken(api, ctx, profileOverride);
+      const response = await fetch(`${resolved.baseUrl}/documents/upload`, {
+        method: "POST",
+        headers: { Authorization: `Bearer ${token}` },
+        body: form,
+      });
+      const text = await response.text();
+      let body: unknown = text;
+      try {
+        body = text ? JSON.parse(text) : {};
+      } catch {
+        // keep text
+      }
+      return json({ ok: response.ok, status: response.status, body, resolved });
+    }
+
+    throw new Error(`Unsupported action: ${String(action)}`);
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    api.logger.warn(`[allbase] tool error: ${message}`);
+    return json({ ok: false, error: message });
+  }
+}
+
+const plugin = {
+  id: "allbase",
+  name: "Allbase",
+  description: "Allbase memory/document tools with per-agent profile mapping",
+  configSchema: emptyPluginConfigSchema(),
+  register(api: OpenClawPluginApi) {
+    api.registerTool(
+      ((ctx: OpenClawPluginToolContext) => {
+        return {
+          name: "allbase",
+          label: "Allbase",
+          description:
+            "Allbase memory + document tools with per-OpenClaw-agent profile mapping. Actions: status, save_memory, save_knowledge, search_memories, upload_document, search_documents.",
+          parameters: AllbaseToolSchema,
+          execute: (toolCallId: string, params: any) => executeAllbaseTool(api, ctx, toolCallId, params),
+        } as AnyAgentTool;
+      }),
+      { optional: true },
+    );
+
+    api.registerCommand({
+      name: "allbase-status",
+      description: "Show resolved Allbase profile for this agent",
+      acceptsArgs: true,
+      requireAuth: true,
+      handler: (cmdCtx) => {
+        const profileOverride = (cmdCtx.args || "").trim() || undefined;
+        try {
+          const resolved = resolveProfile(api, { agentId: cmdCtx.config.defaultAgentId }, profileOverride);
+          return {
+            text:
+              `Allbase profile: ${resolved.profileName}\n` +
+              `Base URL: ${resolved.baseUrl}\n` +
+              `Workspace: ${resolved.profile.workspaceId}\n` +
+              `Allbase Agent: ${resolved.profile.agentId}`,
+          };
+        } catch (err) {
+          return { text: `Allbase profile resolution failed: ${err instanceof Error ? err.message : String(err)}` };
+        }
+      },
+    });
+  },
+};
+
+export default plugin;

package/openclaw.plugin.json

@@ -0,0 +1,43 @@
+{
+  "id": "allbase",
+  "name": "Allbase",
+  "description": "Allbase memory/document tools with per-OpenClaw-agent profile mapping.",
+  "uiHints": {
+    "baseUrl": { "label": "Allbase Base URL", "placeholder": "https://allbase.ai" },
+    "tokenPath": { "label": "Token Path", "advanced": true },
+    "defaultProfile": { "label": "Default Profile" },
+    "profiles": { "label": "Allbase Profiles" },
+    "mapByOpenclawAgent": { "label": "Map OpenClaw Agent ID -> Profile" },
+    "profiles.*.workspaceId": { "label": "Workspace ID" },
+    "profiles.*.agentId": { "label": "Allbase Agent ID" },
+    "profiles.*.apiKey": { "label": "Allbase API Key", "sensitive": true },
+    "profiles.*.baseUrl": { "label": "Profile Base URL", "advanced": true }
+  },
+  "configSchema": {
+    "type": "object",
+    "additionalProperties": false,
+    "properties": {
+      "baseUrl": { "type": "string" },
+      "tokenPath": { "type": "string" },
+      "defaultProfile": { "type": "string" },
+      "profiles": {
+        "type": "object",
+        "additionalProperties": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["workspaceId", "agentId", "apiKey"],
+          "properties": {
+            "workspaceId": { "type": "string" },
+            "agentId": { "type": "string" },
+            "apiKey": { "type": "string" },
+            "baseUrl": { "type": "string" }
+          }
+        }
+      },
+      "mapByOpenclawAgent": {
+        "type": "object",
+        "additionalProperties": { "type": "string" }
+      }
+    }
+  }
+}

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "@allbaseai/openclaw-allbase",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "OpenClaw plugin to map OpenClaw agents to Allbase agent/workspace profiles.",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "index.ts",
+    "openclaw.plugin.json",
+    "README.md",
+    "package.json",
+    "LICENSE"
+  ],
+  "openclaw": {
+    "extensions": [
+      "./index.ts"
+    ]
+  },
+  "dependencies": {
+    "@sinclair/typebox": "^0.34.41"
+  }
+}