feat: OpenClaw multi-agent workspace export (#42)

Author: shreyas-lyzr

src/adapters/openclaw.ts

@@ -15,12 +15,21 @@ import { loadAllSkills, getAllowedTools } from '../utils/skill-loader.js';
  *   - TOOLS.md       (tool definitions)
  *   - skills/<name>/SKILL.md (skill files, passed through)
  */
+export interface SubAgentExport {
+  name: string;
+  soulMd: string;
+  agentsMd: string;
+  toolsMd: string;
+  skills: Array<{ name: string; content: string }>;
+}
+
 export interface OpenClawExport {
   config: object;
   agentsMd: string;
   soulMd: string;
   toolsMd: string;
   skills: Array<{ name: string; content: string }>;
+  subAgents: SubAgentExport[];
 }
 
 export function exportToOpenClaw(dir: string): OpenClawExport {
@@ -42,7 +51,10 @@ export function exportToOpenClaw(dir: string): OpenClawExport {
   // --- Skills (passthrough SKILL.md files) ---
   const skills = collectSkills(agentDir);
 
-  return { config, agentsMd, soulMd, toolsMd, skills };
+  // --- Sub-agents (separate workspaces) ---
+  const subAgents = exportSubAgents(agentDir, manifest);
+
+  return { config, agentsMd, soulMd, toolsMd, skills, subAgents };
 }
 
 /**
@@ -52,40 +64,99 @@ export function exportToOpenClaw(dir: string): OpenClawExport {
 export function exportToOpenClawString(dir: string): string {
   const exp = exportToOpenClaw(dir);
   const parts: string[] = [];
+  const hasSubAgents = exp.subAgents.length > 0;
+  const mainPrefix = hasSubAgents ? `workspace-${exp.config && (exp.config as Record<string, Record<string, string[]>>).agents?.list?.[0] || 'main'}` : 'workspace';
 
   parts.push('# === openclaw.json ===');
   parts.push(JSON.stringify(exp.config, null, 2));
 
-  parts.push('\n# === workspace/AGENTS.md ===');
+  parts.push(`\n# === ${mainPrefix}/AGENTS.md ===`);
   parts.push(exp.agentsMd);
 
-  parts.push('\n# === workspace/SOUL.md ===');
+  parts.push(`\n# === ${mainPrefix}/SOUL.md ===`);
   parts.push(exp.soulMd);
 
   if (exp.toolsMd) {
-    parts.push('\n# === workspace/TOOLS.md ===');
+    parts.push(`\n# === ${mainPrefix}/TOOLS.md ===`);
     parts.push(exp.toolsMd);
   }
 
   for (const skill of exp.skills) {
-    parts.push(`\n# === workspace/skills/${skill.name}/SKILL.md ===`);
+    parts.push(`\n# === ${mainPrefix}/skills/${skill.name}/SKILL.md ===`);
     parts.push(skill.content);
   }
 
+  // Sub-agent workspaces
+  for (const sub of exp.subAgents) {
+    const prefix = `workspace-${sub.name}`;
+
+    parts.push(`\n# === ${prefix}/SOUL.md ===`);
+    parts.push(sub.soulMd);
+
+    parts.push(`\n# === ${prefix}/AGENTS.md ===`);
+    parts.push(sub.agentsMd);
+
+    if (sub.toolsMd) {
+      parts.push(`\n# === ${prefix}/TOOLS.md ===`);
+      parts.push(sub.toolsMd);
+    }
+
+    for (const skill of sub.skills) {
+      parts.push(`\n# === ${prefix}/skills/${skill.name}/SKILL.md ===`);
+      parts.push(skill.content);
+    }
+  }
+
   return parts.join('\n');
 }
 
 function buildOpenClawConfig(agentDir: string, manifest: ReturnType<typeof loadAgentManifest>): object {
+  const mainModel = mapModelName(manifest.model?.preferred ?? 'anthropic/claude-sonnet-4-5-20250929');
+
+  // Check for sub-agents → multi-agent config
+  if (manifest.agents && Object.keys(manifest.agents).length > 0) {
+    const agentNames = ['main', ...Object.keys(manifest.agents)];
+    const agents: Record<string, unknown> = {
+      list: agentNames,
+      main: buildAgentConfig(mainModel, `~/.openclaw/workspace-${manifest.name}`, manifest),
+    };
+
+    for (const name of Object.keys(manifest.agents)) {
+      const subDir = join(agentDir, 'agents', name);
+      let subModel = mainModel;
+      if (existsSync(join(subDir, 'agent.yaml'))) {
+        try {
+          const subManifest = loadAgentManifest(subDir);
+          if (subManifest.model?.preferred) {
+            subModel = mapModelName(subManifest.model.preferred);
+          }
+        } catch { /* use parent model */ }
+      }
+      agents[name] = {
+        model: subModel,
+        workspace: `~/.openclaw/workspace-${name}`,
+      };
+    }
+
+    return { agents };
+  }
+
+  // Single-agent config (unchanged)
   const config: Record<string, unknown> = {
-    agent: {
-      model: mapModelName(manifest.model?.preferred ?? 'anthropic/claude-sonnet-4-5-20250929'),
-      workspace: '~/.openclaw/workspace',
-    },
+    agent: buildAgentConfig(mainModel, '~/.openclaw/workspace', manifest),
   };
 
-  // Map runtime settings
+  return config;
+}
+
+function buildAgentConfig(
+  model: string,
+  workspace: string,
+  manifest: ReturnType<typeof loadAgentManifest>,
+): Record<string, unknown> {
+  const agentConfig: Record<string, unknown> = { model, workspace };
+
   if (manifest.runtime) {
-    const agentConfig = config.agent as Record<string, unknown>;
     if (manifest.runtime.temperature !== undefined) {
       agentConfig.temperature = manifest.runtime.temperature;
     }
@@ -94,12 +165,11 @@ function buildOpenClawConfig(agentDir: string, manifest: ReturnType<typeof loadA
     }
   }
 
-  // Map model constraints
   if (manifest.model?.constraints?.max_tokens) {
-    (config.agent as Record<string, unknown>).maxTokens = manifest.model.constraints.max_tokens;
+    agentConfig.maxTokens = manifest.model.constraints.max_tokens;
   }
 
-  return config;
+  return agentConfig;
 }
 
 /**
@@ -246,6 +316,32 @@ function buildToolsMd(agentDir: string): string {
   return parts.join('\n');
 }
 
+function exportSubAgents(
+  agentDir: string,
+  manifest: ReturnType<typeof loadAgentManifest>,
+): SubAgentExport[] {
+  if (!manifest.agents) return [];
+
+  const subAgents: SubAgentExport[] = [];
+
+  for (const name of Object.keys(manifest.agents)) {
+    const subDir = join(agentDir, 'agents', name);
+    if (!existsSync(subDir)) continue;
+
+    try {
+      const subManifest = loadAgentManifest(subDir);
+      const soulMd = loadFileIfExists(join(subDir, 'SOUL.md')) ?? `# ${subManifest.name}\n${subManifest.description}`;
+      const agentsMd = buildAgentsMd(subDir, subManifest);
+      const toolsMd = buildToolsMd(subDir);
+      const skills = collectSkills(subDir);
+
+      subAgents.push({ name, soulMd, agentsMd, toolsMd, skills });
+    } catch { /* skip malformed sub-agents */ }
+  }
+
+  return subAgents;
+}
+
 function collectSkills(agentDir: string): Array<{ name: string; content: string }> {
   const skills: Array<{ name: string; content: string }> = [];
   const skillsDir = join(agentDir, 'skills');

src/runners/openclaw.ts

@@ -20,25 +20,60 @@ export function runWithOpenClaw(agentDir: string, manifest: AgentManifest, optio
   const workspaceDir = join(tmpdir(), `gitagent-openclaw-${randomBytes(4).toString('hex')}`);
   mkdirSync(workspaceDir, { recursive: true });
 
-  // Write workspace files
-  writeFileSync(join(workspaceDir, 'AGENTS.md'), exp.agentsMd, 'utf-8');
-  writeFileSync(join(workspaceDir, 'SOUL.md'), exp.soulMd, 'utf-8');
+  const hasSubAgents = exp.subAgents.length > 0;
+
+  // Write main workspace files
+  const mainWorkspace = hasSubAgents ? join(workspaceDir, `workspace-main`) : workspaceDir;
+  mkdirSync(mainWorkspace, { recursive: true });
+
+  writeFileSync(join(mainWorkspace, 'AGENTS.md'), exp.agentsMd, 'utf-8');
+  writeFileSync(join(mainWorkspace, 'SOUL.md'), exp.soulMd, 'utf-8');
 
   if (exp.toolsMd) {
-    writeFileSync(join(workspaceDir, 'TOOLS.md'), exp.toolsMd, 'utf-8');
+    writeFileSync(join(mainWorkspace, 'TOOLS.md'), exp.toolsMd, 'utf-8');
   }
 
-  // Write skills
+  // Write main skills
   for (const skill of exp.skills) {
-    const skillDir = join(workspaceDir, 'skills', skill.name);
+    const skillDir = join(mainWorkspace, 'skills', skill.name);
     mkdirSync(skillDir, { recursive: true });
     writeFileSync(join(skillDir, 'SKILL.md'), skill.content, 'utf-8');
   }
 
-  // Write openclaw.json config, pointing workspace to our temp dir
+  // Write sub-agent workspaces
+  for (const sub of exp.subAgents) {
+    const subWorkspace = join(workspaceDir, `workspace-${sub.name}`);
+    mkdirSync(subWorkspace, { recursive: true });
+
+    writeFileSync(join(subWorkspace, 'SOUL.md'), sub.soulMd, 'utf-8');
+    writeFileSync(join(subWorkspace, 'AGENTS.md'), sub.agentsMd, 'utf-8');
+    if (sub.toolsMd) {
+      writeFileSync(join(subWorkspace, 'TOOLS.md'), sub.toolsMd, 'utf-8');
+    }
+    for (const skill of sub.skills) {
+      const skillDir = join(subWorkspace, 'skills', skill.name);
+      mkdirSync(skillDir, { recursive: true });
+      writeFileSync(join(skillDir, 'SKILL.md'), skill.content, 'utf-8');
+    }
+    info(`  Sub-agent workspace: workspace-${sub.name}/`);
+  }
+
+  // Write openclaw.json config, pointing workspaces to temp dirs
   const config = exp.config as Record<string, Record<string, unknown>>;
-  config.agent = config.agent ?? {};
-  config.agent.workspace = workspaceDir;
+  if (hasSubAgents) {
+    const agents = config.agents as Record<string, unknown>;
+    if (agents.main && typeof agents.main === 'object') {
+      (agents.main as Record<string, unknown>).workspace = mainWorkspace;
+    }
+    for (const sub of exp.subAgents) {
+      if (agents[sub.name] && typeof agents[sub.name] === 'object') {
+        (agents[sub.name] as Record<string, unknown>).workspace = join(workspaceDir, `workspace-${sub.name}`);
+      }
+    }
+  } else {
+    config.agent = config.agent ?? {};
+    config.agent.workspace = workspaceDir;
+  }
 
   const configFile = join(workspaceDir, 'openclaw.json');
   writeFileSync(configFile, JSON.stringify(config, null, 2), 'utf-8');