@openagents-org/agent-connector 0.1.10 → 0.2.0

package/src/adapters/index.js

@@ -0,0 +1,39 @@
+/**
+ * Adapter registry — maps agent type names to adapter classes.
+ */
+
+'use strict';
+
+const BaseAdapter = require('./base');
+const OpenClawAdapter = require('./openclaw');
+const ClaudeAdapter = require('./claude');
+const CodexAdapter = require('./codex');
+
+const ADAPTER_MAP = {
+  openclaw: OpenClawAdapter,
+  claude: ClaudeAdapter,
+  codex: CodexAdapter,
+};
+
+/**
+ * Create an adapter instance for the given agent type.
+ * @param {string} type - Agent type (openclaw, claude, codex)
+ * @param {object} opts - Adapter constructor options
+ * @returns {BaseAdapter}
+ */
+function createAdapter(type, opts) {
+  const AdapterClass = ADAPTER_MAP[type];
+  if (!AdapterClass) {
+    throw new Error(`Unknown agent type: ${type}. Supported: ${Object.keys(ADAPTER_MAP).join(', ')}`);
+  }
+  return new AdapterClass(opts);
+}
+
+module.exports = {
+  BaseAdapter,
+  OpenClawAdapter,
+  ClaudeAdapter,
+  CodexAdapter,
+  createAdapter,
+  ADAPTER_MAP,
+};

package/src/adapters/openclaw.js

@@ -0,0 +1,259 @@
+/**
+ * OpenClaw adapter for OpenAgents workspace.
+ *
+ * Bridges OpenClaw to an OpenAgents workspace via:
+ * - CLI mode: `openclaw agent --local --json` (preferred)
+ * - Workspace context injected via SKILL.md auto-discovery
+ *
+ * Direct port of Python: src/openagents/adapters/openclaw.py
+ * (CLI mode only — gateway WS and direct HTTP modes are not yet ported)
+ */
+
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { spawn, execSync } = require('child_process');
+
+const BaseAdapter = require('./base');
+const { formatAttachmentsForPrompt } = require('./utils');
+const { buildOpenclawSkillMd, buildOpenclawSystemPrompt } = require('./workspace-prompt');
+
+const IS_WINDOWS = process.platform === 'win32';
+const OPENCLAW_STATE_DIR = path.join(
+  IS_WINDOWS ? (process.env.USERPROFILE || '') : (process.env.HOME || ''),
+  '.openclaw'
+);
+
+class OpenClawAdapter extends BaseAdapter {
+  /**
+   * @param {object} opts - BaseAdapter opts plus:
+   * @param {string} [opts.openclawAgentId='main']
+   * @param {Set} [opts.disabledModules]
+   */
+  constructor(opts) {
+    super(opts);
+    this.openclawAgentId = opts.openclawAgentId || 'main';
+    this.disabledModules = opts.disabledModules || new Set();
+
+    // Conversation history for multi-turn context
+    this._conversationHistory = [];
+    this._maxHistory = 50;
+
+    // Find the openclaw binary
+    this._openclawBinary = this._findOpenclawBinary();
+    if (this._openclawBinary) {
+      this._log(`Using OpenClaw CLI mode (${this._openclawBinary})`);
+    } else {
+      this._log('OpenClaw binary not found — agent will not be able to process messages');
+    }
+
+    // Install workspace skill
+    this._installWorkspaceSkill();
+  }
+
+  // ------------------------------------------------------------------
+  // Binary resolution
+  // ------------------------------------------------------------------
+
+  _findOpenclawBinary() {
+    try {
+      const cmd = IS_WINDOWS ? 'where openclaw' : 'which openclaw';
+      const result = execSync(cmd, { encoding: 'utf-8', timeout: 5000 })
+        .split(/\r?\n/)[0].trim();
+      if (result) return result;
+    } catch {}
+
+    // Check common npm global directories
+    const dirs = [];
+    if (IS_WINDOWS) {
+      const appdata = process.env.APPDATA || '';
+      if (appdata) dirs.push(path.join(appdata, 'npm'));
+    } else {
+      const home = process.env.HOME || '';
+      dirs.push(path.join(home, '.npm-global', 'bin'), '/usr/local/bin');
+    }
+    for (const d of dirs) {
+      for (const name of ['openclaw.cmd', 'openclaw']) {
+        const candidate = path.join(d, name);
+        if (fs.existsSync(candidate)) return candidate;
+      }
+    }
+    return null;
+  }
+
+  // ------------------------------------------------------------------
+  // Workspace skill installation
+  // ------------------------------------------------------------------
+
+  _resolveOpenclawWorkspace() {
+    const agentId = this.openclawAgentId;
+    const wsDir = agentId && agentId !== 'main'
+      ? path.join(OPENCLAW_STATE_DIR, `workspace-${agentId}`)
+      : path.join(OPENCLAW_STATE_DIR, 'workspace');
+
+    if (fs.existsSync(wsDir)) return wsDir;
+
+    // Fall back to default workspace
+    const fallback = path.join(OPENCLAW_STATE_DIR, 'workspace');
+    if (fs.existsSync(fallback)) return fallback;
+
+    return null;
+  }
+
+  _installWorkspaceSkill() {
+    const wsDir = this._resolveOpenclawWorkspace();
+    if (!wsDir) {
+      this._log('OpenClaw workspace not found, skipping skill install');
+      return;
+    }
+
+    const skillName = `openagents-workspace-${this.agentName}`;
+    const skillDir = path.join(wsDir, 'skills', skillName);
+    fs.mkdirSync(skillDir, { recursive: true });
+
+    const content = buildOpenclawSkillMd({
+      endpoint: this.endpoint,
+      workspaceId: this.workspaceId,
+      token: this.token,
+      agentName: this.agentName,
+      channelName: this.channelName,
+      disabledModules: this.disabledModules,
+    });
+
+    const skillPath = path.join(skillDir, 'SKILL.md');
+    fs.writeFileSync(skillPath, content, 'utf-8');
+    this._log(`Installed workspace skill at ${skillPath}`);
+  }
+
+  // ------------------------------------------------------------------
+  // Message handling
+  // ------------------------------------------------------------------
+
+  async _handleMessage(msg) {
+    let content = (msg.content || '').trim();
+    const attachments = msg.attachments || [];
+
+    // Append attachment info
+    const attText = formatAttachmentsForPrompt(attachments);
+    if (attText) {
+      content = content ? content + attText : attText.trim();
+    }
+
+    if (!content) return;
+
+    const msgChannel = msg.sessionId || this.channelName;
+    const sender = msg.senderName || msg.senderType || 'user';
+    this._log(`Processing message from ${sender} in ${msgChannel}: ${content.slice(0, 80)}...`);
+
+    await this._autoTitleChannel(msgChannel, content);
+    await this.sendStatus(msgChannel, 'thinking...');
+
+    try {
+      const responseText = await this._runCliAgent(content, msgChannel);
+
+      if (responseText) {
+        this._conversationHistory.push({ role: 'user', content });
+        this._conversationHistory.push({ role: 'assistant', content: responseText });
+        if (this._conversationHistory.length > this._maxHistory * 2) {
+          this._conversationHistory = this._conversationHistory.slice(-this._maxHistory * 2);
+        }
+        await this.sendResponse(msgChannel, responseText);
+      } else {
+        await this.sendResponse(msgChannel, 'No response generated. Please try again.');
+      }
+    } catch (e) {
+      this._log(`Error handling message: ${e.message}`);
+      await this.sendError(msgChannel, `Error processing message: ${e.message}`);
+    }
+  }
+
+  // ------------------------------------------------------------------
+  // CLI mode (openclaw agent --local)
+  // ------------------------------------------------------------------
+
+  _runCliAgent(userMessage, channel) {
+    return new Promise((resolve, reject) => {
+      const binary = this._openclawBinary;
+      if (!binary) {
+        reject(new Error('OpenClaw binary not found'));
+        return;
+      }
+
+      const sessionKey = `openagents-${this.workspaceId.slice(0, 8)}-${channel.slice(-8)}`;
+
+      const args = [
+        'agent', '--local',
+        '--agent', this.openclawAgentId,
+        '--session-id', sessionKey,
+        '--message', userMessage,
+        '--json',
+      ];
+
+      this._log(`CLI: ${binary} ${args.slice(0, 5).join(' ')} ...`);
+
+      const spawnEnv = { ...process.env };
+      if (IS_WINDOWS) {
+        const npmBin = path.join(process.env.APPDATA || '', 'npm');
+        if (npmBin && !(spawnEnv.PATH || '').includes(npmBin)) {
+          spawnEnv.PATH = npmBin + ';' + (spawnEnv.PATH || '');
+        }
+      }
+
+      let spawnBinary = binary;
+      let spawnArgs = args;
+      const spawnOpts = {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        env: spawnEnv,
+        timeout: 600000,
+      };
+
+      if (IS_WINDOWS) {
+        spawnBinary = process.env.COMSPEC || 'cmd.exe';
+        const quotedArgs = args.map((a) => a.includes(' ') ? `"${a}"` : a);
+        spawnArgs = ['/C', binary, ...quotedArgs];
+      }
+
+      const proc = spawn(spawnBinary, spawnArgs, spawnOpts);
+      let stdout = '';
+      let stderr = '';
+
+      if (proc.stdout) proc.stdout.on('data', (d) => { stdout += d; });
+      if (proc.stderr) proc.stderr.on('data', (d) => { stderr += d; });
+
+      proc.on('error', (err) => reject(err));
+      proc.on('exit', (code) => {
+        if (code !== 0) {
+          reject(new Error(`CLI exited ${code}: ${stderr.slice(0, 300)}`));
+          return;
+        }
+
+        stdout = stdout.trim();
+        if (!stdout) { resolve(''); return; }
+
+        // Parse JSON output — find first '{'
+        const jsonStart = stdout.indexOf('{');
+        if (jsonStart < 0) { resolve(stdout); return; }
+
+        try {
+          const data = JSON.parse(stdout.slice(jsonStart));
+          // Extract response text from JSON
+          const payloads = data.payloads || [];
+          if (payloads.length > 0) {
+            const texts = payloads
+              .filter((p) => p.text)
+              .map((p) => p.text);
+            resolve(texts.join('\n\n'));
+          } else {
+            resolve('');
+          }
+        } catch {
+          // Failed to parse JSON — return raw output
+          resolve(stdout);
+        }
+      });
+    });
+  }
+}
+
+module.exports = OpenClawAdapter;

package/src/adapters/utils.js

@@ -0,0 +1,83 @@
+/**
+ * Shared utilities for adapter implementations.
+ *
+ * Direct port of Python: src/openagents/adapters/utils.py
+ */
+
+'use strict';
+
+const SESSION_DEFAULT_RE = /^(Session \d+|session-[0-9a-f]+|channel-[0-9a-f]+)$/;
+
+/**
+ * Generate a short session title from the first user message.
+ */
+function generateSessionTitle(message, maxWords = 6) {
+  // Collapse whitespace, strip code blocks
+  let text = message.replace(/\s+/g, ' ').trim();
+  text = text.replace(/```[\s\S]*?```/g, '').trim();
+  text = text.replace(/`[^`]+`/g, '').trim();
+
+  if (!text) return '';
+
+  // Try to get first sentence
+  const sentenceMatch = text.match(/^(.+?[.!?])\s/);
+  if (sentenceMatch) {
+    text = sentenceMatch[1].replace(/[.!?]+$/, '').trim();
+  }
+
+  // Take first maxWords words
+  const words = text.split(/\s+/);
+  if (words.length > maxWords) {
+    text = words.slice(0, maxWords).join(' ');
+  }
+
+  // Strip common filler prefixes
+  text = text.replace(
+    /^(hey|hi|hello|please|can you|could you|i need you to|i want you to)\s+/i,
+    ''
+  ).trim();
+
+  // Capitalize first letter
+  if (text) {
+    text = text[0].toUpperCase() + text.slice(1);
+  }
+
+  // Hard cap at 50 characters
+  if (text.length > 50) {
+    text = text.slice(0, 47) + '...';
+  }
+
+  return text;
+}
+
+/**
+ * Format attachment metadata into text to append to an agent prompt.
+ */
+function formatAttachmentsForPrompt(attachments) {
+  if (!attachments || attachments.length === 0) return null;
+
+  const lines = ['\n[Attached files]'];
+  for (const att of attachments) {
+    const filename = att.filename || 'unknown';
+    const fileId = att.fileId || '';
+    const contentType = att.contentType || '';
+    if (contentType.startsWith('image/')) {
+      lines.push(
+        `- Image: ${filename} (file_id: ${fileId}) — ` +
+        'use workspace_read_file to view this image'
+      );
+    } else {
+      lines.push(
+        `- File: ${filename} (file_id: ${fileId}, type: ${contentType}) — ` +
+        'use workspace_read_file to read this file'
+      );
+    }
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  SESSION_DEFAULT_RE,
+  generateSessionTitle,
+  formatAttachmentsForPrompt,
+};

package/src/adapters/workspace-prompt.js

@@ -0,0 +1,293 @@
+/**
+ * Shared workspace prompt builder for all adapters.
+ *
+ * Generates system prompt sections that teach agents about:
+ * - Their identity and workspace context
+ * - Multi-agent collaboration (@mention delegation)
+ * - Workspace REST API skills (files, browser, tunnels)
+ *
+ * Direct port of Python: src/openagents/adapters/workspace_prompt.py
+ */
+
+'use strict';
+
+/**
+ * Build the identity section common to all adapters.
+ */
+function buildWorkspaceIdentity(agentName, workspaceId, channelName, mode = 'execute') {
+  return (
+    `You are agent '${agentName}' connected to an OpenAgents workspace.\n` +
+    'Your text responses are automatically posted to the workspace chat ' +
+    '— just write your answer naturally.\n\n' +
+    '## Workspace Context\n' +
+    `- Workspace ID: ${workspaceId}\n` +
+    `- Channel: ${channelName}\n` +
+    `- Mode: ${mode}\n`
+  );
+}
+
+/**
+ * Build the multi-agent collaboration instructions.
+ */
+function buildCollaborationPrompt() {
+  return (
+    '\n## Multi-Agent Collaboration\n' +
+    'To delegate work to another agent, @mention them in your response. ' +
+    'Only @mentioned agents will receive the message.\n\n' +
+    'IMPORTANT: Do NOT @mention an agent just to say thanks or acknowledge ' +
+    '— that wakes them up for nothing. Only @mention when you need them ' +
+    'to do work. When the task is complete, report results to the user ' +
+    'without @mentioning other agents.\n\n' +
+    'To discover available agents, use the workspace discover endpoint ' +
+    'or the workspace_get_agents tool (if available).\n'
+  );
+}
+
+/**
+ * Build mode-specific instructions.
+ */
+function buildModePrompt(mode) {
+  if (mode === 'plan') {
+    return (
+      '\n## Mode: PLAN\n' +
+      'You are in PLAN mode. Only read, analyze, and propose.\n' +
+      '- Do NOT write code, make changes, or execute actions.\n' +
+      '- Outline your plan step by step.\n' +
+      '- Describe what changes you would make and why.\n' +
+      '- Ask clarifying questions if needed.\n' +
+      '- When the user is satisfied, they can switch you to Execute mode.\n'
+    );
+  }
+  return (
+    '\n## Mode: EXECUTE\n' +
+    'You are in EXECUTE mode. You can write code, make changes, ' +
+    'and take actions.\n' +
+    'Be helpful, concise, and direct. Use markdown formatting.\n'
+  );
+}
+
+/**
+ * Build REST API skill instructions for non-MCP agents.
+ *
+ * These teach the agent how to interact with workspace resources
+ * (files, browser, tunnels) by calling HTTP endpoints directly.
+ *
+ * In plan mode, only read-only operations are documented.
+ */
+function buildApiSkillsPrompt({ endpoint, workspaceId, token, agentName, channelName, disabledModules, mode = 'execute' }) {
+  const disabled = disabledModules || new Set();
+  const baseUrl = endpoint.replace(/\/+$/, '');
+  const isPlan = mode === 'plan';
+  const h = `X-Workspace-Token: ${token}`;
+
+  const sections = [];
+
+  // Capabilities preamble
+  const caps = [];
+  if (!disabled.has('files')) caps.push('share and read files with other agents and users');
+  if (!disabled.has('browser')) caps.push('browse websites in a shared browser');
+  caps.push('discover other agents in the workspace');
+
+  sections.push(
+    '## Workspace Tools (MANDATORY)\n\n' +
+    'You can ' + caps.join(', ') + '.\n' +
+    'These are WORKSPACE tools shared with all agents and users. ' +
+    'They are different from your native tools.\n\n' +
+    '**HOW TO USE:** Call your `exec` tool to run the `curl` commands below. ' +
+    'Do NOT output curl commands as text — EXECUTE them with `exec`.\n\n' +
+    '**IMPORTANT — tool priority:**\n' +
+    '- ALWAYS use `exec` + `curl` (documented below) for workspace operations.\n' +
+    '- Do NOT use `workspace_browser_*` native tools — they are not configured ' +
+    'and will fail.\n' +
+    '- Do NOT use `web_fetch`, `browser`, or any native browsing tool ' +
+    'when the user asks to use the workspace browser — use `exec` + `curl` instead.\n' +
+    '- The workspace browser is a *shared* browser visible to all users and agents.\n\n' +
+    '**Auth header** (include on every request):\n' +
+    `\`X-Workspace-Token: ${token}\`\n`
+  );
+
+  // Files
+  if (!disabled.has('files')) {
+    let s = '\n### Shared Files\n\n';
+
+    if (!isPlan) {
+      s += (
+        '**To upload a file**, exec this (replace filename/content):\n' +
+        `CONTENT=$(echo -n 'YOUR_CONTENT' | base64) && ` +
+        `curl -s -X POST ${baseUrl}/v1/files/base64 ` +
+        `-H "${h}" ` +
+        '-H "Content-Type: application/json" ' +
+        `-d '{"filename":"report.md",` +
+        `"content_base64":"'"$CONTENT"'",` +
+        `"content_type":"text/markdown",` +
+        `"network":"${workspaceId}",` +
+        `"source":"openagents:${agentName}",` +
+        `"channel_name":"${channelName}"}'\n\n`
+      );
+    }
+
+    s += (
+      '**List files:**\n' +
+      `\`curl -s -H "${h}" ${baseUrl}/v1/files?network=${workspaceId}\`\n\n` +
+      '**Download file:**\n' +
+      `\`curl -s -H "${h}" ${baseUrl}/v1/files/{file_id}\`\n\n` +
+      '**File info (metadata):**\n' +
+      `\`curl -s -H "${h}" ${baseUrl}/v1/files/{file_id}/info\`\n`
+    );
+
+    if (!isPlan) {
+      s += (
+        '\n**Delete file:**\n' +
+        `\`curl -s -X DELETE -H "${h}" ${baseUrl}/v1/files/{file_id}\`\n`
+      );
+    }
+
+    sections.push(s);
+  }
+
+  // Browser
+  if (!disabled.has('browser')) {
+    let s = '\n### Shared Browser\n\n';
+
+    if (!isPlan) {
+      s += (
+        '**To browse a website**, exec these steps (use exec for each):\n' +
+        `Step 1 — open tab: ` +
+        `curl -s -X POST ${baseUrl}/v1/browser/tabs ` +
+        `-H "${h}" -H "Content-Type: application/json" ` +
+        `-d '{"url":"https://example.com","network":"${workspaceId}",` +
+        `"source":"openagents:${agentName}"}'\n` +
+        `Step 2 — read content: ` +
+        `curl -s -H "${h}" ${baseUrl}/v1/browser/tabs/TAB_ID/snapshot\n` +
+        `Step 3 — close tab: ` +
+        `curl -s -X DELETE -H "${h}" ${baseUrl}/v1/browser/tabs/TAB_ID\n` +
+        '(Replace TAB_ID with the id from step 1 response)\n\n'
+      );
+    }
+
+    s += (
+      '**List open tabs:**\n' +
+      `\`curl -s -H "${h}" ${baseUrl}/v1/browser/tabs?network=${workspaceId}\`\n\n` +
+      '**Get page content (text):**\n' +
+      `\`curl -s -H "${h}" ${baseUrl}/v1/browser/tabs/{tab_id}/snapshot\`\n\n` +
+      '**Get screenshot (PNG):**\n' +
+      `\`curl -s -H "${h}" ${baseUrl}/v1/browser/tabs/{tab_id}/screenshot\`\n`
+    );
+
+    if (!isPlan) {
+      s += (
+        '\n**Open tab:**\n' +
+        `\`curl -s -X POST -H "${h}" -H "Content-Type: application/json"` +
+        ` ${baseUrl}/v1/browser/tabs` +
+        ` -d '{"url":"URL","network":"${workspaceId}",` +
+        `"source":"openagents:${agentName}"}'\`\n\n` +
+        '**Navigate:**\n' +
+        `\`curl -s -X POST -H "${h}" -H "Content-Type: application/json"` +
+        ` ${baseUrl}/v1/browser/tabs/{tab_id}/navigate` +
+        ` -d '{"url":"URL"}'\`\n\n` +
+        '**Click element:**\n' +
+        `\`curl -s -X POST -H "${h}" -H "Content-Type: application/json"` +
+        ` ${baseUrl}/v1/browser/tabs/{tab_id}/click` +
+        ` -d '{"selector":"CSS_SELECTOR"}'\`\n\n` +
+        '**Type text:**\n' +
+        `\`curl -s -X POST -H "${h}" -H "Content-Type: application/json"` +
+        ` ${baseUrl}/v1/browser/tabs/{tab_id}/type` +
+        ` -d '{"selector":"CSS_SELECTOR","text":"TEXT"}'\`\n\n` +
+        '**Close tab:**\n' +
+        `\`curl -s -X DELETE -H "${h}" ${baseUrl}/v1/browser/tabs/{tab_id}\`\n`
+      );
+    }
+
+    sections.push(s);
+  }
+
+  // Discovery
+  sections.push(
+    '\n### Discover Agents\n' +
+    `\`curl -s -H "${h}" ${baseUrl}/v1/discover?network=${workspaceId}\`\n`
+  );
+
+  return sections.join('\n');
+}
+
+/**
+ * Build the system prompt for Claude adapter (MCP-based).
+ * Claude gets identity + collaboration instructions but NOT API skills.
+ */
+function buildClaudeSystemPrompt({ agentName, workspaceId, channelName, mode = 'execute' }) {
+  const parts = [];
+  parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode));
+  parts.push(
+    'Use workspace_get_history to read previous messages.\n' +
+    'Use workspace_get_agents to see other agents.\n'
+  );
+  parts.push(buildCollaborationPrompt());
+
+  if (mode === 'plan') {
+    parts.push(
+      '\nYou are in PLAN mode. Only read, analyze, and propose ' +
+      'changes. Do not make edits.\n'
+    );
+  }
+
+  parts.push(
+    '\nIMPORTANT: Never use AskUserQuestion. ' +
+    'AskUserQuestion blocks the subprocess and will hang the thread. ' +
+    'If you need to ask the user something, just write the question ' +
+    'as your text response.\n'
+  );
+
+  return parts.join('\n');
+}
+
+/**
+ * Build the full system prompt for OpenClaw/non-MCP agents.
+ */
+function buildOpenclawSystemPrompt({ agentName, workspaceId, channelName, endpoint, token, mode = 'execute', disabledModules }) {
+  const parts = [];
+  parts.push(buildWorkspaceIdentity(agentName, workspaceId, channelName, mode));
+  parts.push(buildCollaborationPrompt());
+  parts.push(buildModePrompt(mode));
+  parts.push(buildApiSkillsPrompt({
+    endpoint, workspaceId, token, agentName, channelName, disabledModules, mode,
+  }));
+  return parts.join('\n');
+}
+
+/**
+ * Build a SKILL.md file for OpenClaw's skill auto-discovery.
+ */
+function buildOpenclawSkillMd({ endpoint, workspaceId, token, agentName, channelName, disabledModules }) {
+  const body = buildApiSkillsPrompt({
+    endpoint, workspaceId, token, agentName, channelName, disabledModules, mode: 'execute',
+  });
+
+  const identity = buildWorkspaceIdentity(agentName, workspaceId, channelName, 'execute');
+  const collab = buildCollaborationPrompt();
+
+  const frontmatter = (
+    '---\n' +
+    'name: openagents-workspace\n' +
+    'description: "Share files, browse websites, and collaborate ' +
+    'with other agents in an OpenAgents workspace. Use when: ' +
+    '(1) sharing results or reports with the user or other agents, ' +
+    '(2) browsing a website to gather information, ' +
+    '(3) reading files shared by users or other agents, ' +
+    '(4) checking who else is in the workspace."\n' +
+    'metadata:\n' +
+    '  {"openclaw": {"always": true, "emoji": "\\U0001F310"}}\n' +
+    '---\n\n'
+  );
+
+  return frontmatter + identity + '\n' + collab + '\n' + body;
+}
+
+module.exports = {
+  buildWorkspaceIdentity,
+  buildCollaborationPrompt,
+  buildModePrompt,
+  buildApiSkillsPrompt,
+  buildClaudeSystemPrompt,
+  buildOpenclawSystemPrompt,
+  buildOpenclawSkillMd,
+};