@agent-spaces/server 0.3.67 → 0.4.0

package/dist/storage/chat-store.js

@@ -0,0 +1,151 @@
+import { getDataDir, ensureDir, readJsonFile, writeJsonFile, deleteFile } from './json-store.js';
+import path from 'node:path';
+import { existsSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs';
+function chatDir() {
+    return path.join(getDataDir(), 'chat');
+}
+function chatTemplatesDir() {
+    return path.join(getDataDir(), 'chat-templates');
+}
+export function agentDir(agentId) {
+    return path.join(chatTemplatesDir(), agentId);
+}
+function agentFile(agentId) {
+    return path.join(agentDir(agentId), 'agent.json');
+}
+function mcpFile(agentId) {
+    return path.join(agentDir(agentId), 'mcp.json');
+}
+function skillsDir(agentId) {
+    return path.join(agentDir(agentId), 'skills');
+}
+export function chatSessionDir(chatId) {
+    return path.join(chatDir(), chatId);
+}
+export function chatWorkspaceDir(chatId) {
+    return path.join(chatSessionDir(chatId), 'workspaces');
+}
+function chatWorkspaceSkillsDir(chatId) {
+    return path.join(chatWorkspaceDir(chatId), 'skills');
+}
+export function messageHistoryDir(agentId) {
+    return chatSessionDir(agentId);
+}
+function messagesFile(chatId) {
+    return path.join(chatSessionDir(chatId), 'messages.json');
+}
+// --- Agent functions ---
+export function listAgents() {
+    ensureDir(chatTemplatesDir());
+    return readdirSync(chatTemplatesDir(), { withFileTypes: true })
+        .filter(entry => entry.isDirectory())
+        .flatMap(entry => {
+        const agent = readJsonFile(agentFile(entry.name));
+        return agent ? [agent] : [];
+    })
+        .sort((a, b) => a.createdAt.localeCompare(b.createdAt));
+}
+export function saveAgent(agent, skillInputs) {
+    const dir = agentDir(agent.id);
+    ensureDir(dir);
+    ensureDir(skillsDir(agent.id));
+    ensureDir(chatWorkspaceDir(agent.id));
+    ensureDir(chatWorkspaceSkillsDir(agent.id));
+    writeJsonFile(agentFile(agent.id), agent);
+    writeJsonFile(mcpFile(agent.id), agent.mcps ?? {});
+    writeSkills(agent.id, skillInputs, agent.skills ?? []);
+}
+export function findAgent(id) {
+    return readJsonFile(agentFile(id)) ?? undefined;
+}
+export function deleteAgent(id) {
+    rmSync(agentDir(id), { recursive: true, force: true });
+    rmSync(chatSessionDir(id), { recursive: true, force: true });
+}
+// --- Message functions ---
+export function listMessages(agentId, limit, before) {
+    ensureDir(chatSessionDir(agentId));
+    let messages = readJsonFile(messagesFile(agentId)) ?? [];
+    messages = messages.filter(msg => msg.agentId === agentId);
+    // Sort descending by timestamp
+    messages.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    // Cursor pagination: skip messages at or after 'before' timestamp
+    if (before) {
+        const idx = messages.findIndex(m => m.timestamp <= before);
+        if (idx === -1) {
+            messages = [];
+        }
+        else {
+            messages = messages.slice(idx);
+        }
+    }
+    // Apply limit
+    if (limit && limit > 0) {
+        messages = messages.slice(0, limit);
+    }
+    // Return ascending order
+    messages.reverse();
+    return messages;
+}
+export function saveMessage(msg) {
+    const messages = readJsonFile(messagesFile(msg.agentId)) ?? [];
+    messages.push(msg);
+    writeJsonFile(messagesFile(msg.agentId), messages);
+}
+export function deleteMessagesByAgent(agentId) {
+    deleteFile(messagesFile(agentId));
+}
+export function getRecentMessages(agentId, limit = 50) {
+    return listMessages(agentId, limit);
+}
+function writeSkills(agentId, skillInputs, skillNames) {
+    const dir = skillsDir(agentId);
+    if (skillInputs?.some(skill => typeof skill !== 'string')) {
+        rmSync(dir, { recursive: true, force: true });
+        ensureDir(dir);
+        for (const skill of skillInputs) {
+            if (typeof skill === 'string' || !skill.name.trim())
+                continue;
+            const filename = sanitizeMarkdownFilename(skill.name);
+            const content = skill.content ?? readSkillContent(skill.name) ?? '';
+            writeJsonSkillFile(path.join(dir, filename), content);
+            writeJsonSkillFile(path.join(chatWorkspaceSkillsDir(agentId), filename), content);
+        }
+        return;
+    }
+    for (const name of skillNames.map(skill => typeof skill === 'string' ? skill : skill.name)) {
+        const filename = sanitizeMarkdownFilename(name);
+        const content = readSkillContent(name) ?? '';
+        const filePath = path.join(dir, filename);
+        if (content || !existsSync(filePath))
+            writeJsonSkillFile(filePath, content);
+        const workspaceSkillPath = path.join(chatWorkspaceSkillsDir(agentId), filename);
+        if (content || !existsSync(workspaceSkillPath))
+            writeJsonSkillFile(workspaceSkillPath, content);
+    }
+}
+function writeJsonSkillFile(filePath, content) {
+    ensureDir(path.dirname(filePath));
+    writeFileSync(filePath, content, 'utf-8');
+}
+function sanitizeMarkdownFilename(name) {
+    const base = name.trim().replace(/[/\\:*?"<>|]+/g, '-');
+    return base.toLowerCase().endsWith('.md') ? base : `${base}.md`;
+}
+function readSkillContent(name) {
+    const skillName = name.trim().replace(/\.md$/i, '');
+    if (!skillName)
+        return undefined;
+    const candidates = [
+        path.join(getDataDir(), 'skills', skillName, 'SKILL.md'),
+        path.join(getDataDir(), 'skills', `${skillName}.md`),
+        path.join(process.cwd(), 'skills', skillName, 'SKILL.md'),
+        path.join(process.cwd(), 'skills', `${skillName}.md`),
+    ];
+    const source = candidates.find(file => existsSync(file));
+    if (!source)
+        return undefined;
+    const content = readFileSync(source, 'utf-8');
+    return content.trim() ? content : undefined;
+}
+//# sourceMappingURL=chat-store.js.map

package/dist/storage/database-store.js

@@ -362,4 +362,10 @@ export function listDatabaseEmbeddings(workspaceId, databaseId) {
         embedding: JSON.parse(row.embedding),
     }));
 }
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}
 //# sourceMappingURL=database-store.js.map

package/dist/storage/json-store.js

@@ -1,6 +1,7 @@
 import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from 'node:fs';
 import { join, dirname } from 'node:path';
-const DEFAULT_DATA_DIR = join(process.env.HOME || '~', '.agent-spaces-data');
+import { homedir } from 'node:os';
+const DEFAULT_DATA_DIR = join(process.env.HOME || process.env.USERPROFILE || homedir(), '.agent-spaces-data');
 export function getDataDir() {
     return process.env.AGENT_SPACES_DATA_DIR || DEFAULT_DATA_DIR;
 }

package/dist/storage/kanban-store.js

@@ -139,4 +139,10 @@ export function saveTasks(boardId, tasks) {
     }
     database.prepare('UPDATE kanban_boards SET updated_at = ? WHERE id = ?').run(Date.now(), boardId);
 }
+export function closeDb() {
+    if (db) {
+        db.close();
+        db = null;
+    }
+}
 //# sourceMappingURL=kanban-store.js.map

package/dist/storage/workflow-store.js

@@ -1,40 +1,404 @@
 // packages/server/src/storage/workflow-store.ts
-// NOTE: All functions are synchronous to match json-store.ts and issue-store.ts patterns
-import { ensureDir, readJsonFile, writeJsonFile, deleteFile, getDataDir } from './json-store.js';
+// Per-workflow directory storage: supports versions, execution logs, plugin configs.
+// Legacy flat-file workflows are auto-migrated on first access.
+import { ensureDir, readJsonFile, writeJsonFile, getDataDir } from './json-store.js';
+import { existsSync, readdirSync, rmSync, unlinkSync, readFileSync } from 'node:fs';
 import path from 'node:path';
-function workflowsDir() {
+// ---- Path helpers ----
+export function workflowsDir() {
     return path.join(getDataDir(), 'workflows');
 }
-function workflowsIndex() {
+function workflowDir(workflowId) {
+    return path.join(workflowsDir(), workflowId);
+}
+function workflowPath(workflowId) {
+    return path.join(workflowDir(workflowId), 'workflow.json');
+}
+function workflowIndexPath() {
     return path.join(workflowsDir(), 'index.json');
 }
-function workflowFile(workflowId) {
+function versionsDir(workflowId) {
+    return path.join(workflowDir(workflowId), 'versions');
+}
+function executionHistoryDir(workflowId) {
+    return path.join(workflowDir(workflowId), 'execution_history');
+}
+function pluginConfigsDir(workflowId) {
+    return path.join(workflowDir(workflowId), 'plugin_configs');
+}
+function pluginSchemePath(workflowId, pluginId, schemeName) {
+    return path.join(pluginConfigsDir(workflowId), pluginId, `${schemeName}.json`);
+}
+function workflowFoldersPath() {
+    return path.join(workflowsDir(), 'folders.json');
+}
+function stagingPath(workflowId) {
+    return path.join(workflowDir(workflowId), 'staging.json');
+}
+function operationHistoryPath(workflowId) {
+    return path.join(workflowDir(workflowId), 'operation_history.json');
+}
+function chatPath(workflowId) {
+    return path.join(workflowDir(workflowId), 'chat.json');
+}
+// ---- Legacy migration ----
+function legacyWorkflowPath(workflowId) {
     return path.join(workflowsDir(), `${workflowId}.json`);
 }
-export function listWorkflows() {
-    return readJsonFile(workflowsIndex()) ?? [];
+function migrateFromLegacyFormat() {
+    const dir = workflowsDir();
+    if (!existsSync(dir))
+        return;
+    // Read legacy index
+    const indexPath = workflowIndexPath();
+    const legacyIndex = readJsonFile(indexPath);
+    if (!Array.isArray(legacyIndex) || legacyIndex.length === 0)
+        return;
+    // Check if already migrated (has per-workflow dirs)
+    const entries = readdirSync(dir, { withFileTypes: true });
+    const hasWorkflowDirs = entries.some(e => e.isDirectory() && existsSync(path.join(dir, e.name, 'workflow.json')));
+    if (hasWorkflowDirs)
+        return;
+    // Migrate each legacy workflow
+    for (const entry of legacyIndex) {
+        const legacyFile = legacyWorkflowPath(entry.id);
+        if (!existsSync(legacyFile))
+            continue;
+        try {
+            const raw = JSON.parse(readFileSync(legacyFile, 'utf-8'));
+            const migrated = migrateLegacyWorkflow(raw);
+            ensureDir(workflowDir(migrated.id));
+            writeJsonFile(workflowPath(migrated.id), migrated);
+            unlinkSync(legacyFile);
+        }
+        catch {
+            // Skip broken files
+        }
+    }
+    // Remove legacy index
+    unlinkSync(indexPath);
+}
+function migrateLegacyWorkflow(raw) {
+    return {
+        id: raw.id,
+        name: raw.name,
+        folderId: raw.folderId ?? null,
+        description: raw.description,
+        nodes: Array.isArray(raw.nodes) ? raw.nodes.map(migrateLegacyNode) : [],
+        edges: Array.isArray(raw.edges) ? raw.edges.map(migrateLegacyEdge) : [],
+        createdAt: typeof raw.createdAt === 'string' ? Date.parse(raw.createdAt) : (raw.createdAt || Date.now()),
+        updatedAt: typeof raw.updatedAt === 'string' ? Date.parse(raw.updatedAt) : (raw.updatedAt || Date.now()),
+    };
+}
+function migrateLegacyNode(node) {
+    return {
+        id: node.id,
+        type: node.type || 'agent',
+        label: node.data?.label || node.label || '',
+        position: node.position || { x: 0, y: 0 },
+        data: { ...node.data },
+    };
+}
+function migrateLegacyEdge(edge) {
+    return {
+        id: edge.id,
+        source: edge.source,
+        target: edge.target,
+        sourceHandle: edge.sourceHandle ?? null,
+        targetHandle: edge.targetHandle ?? null,
+    };
+}
+// ---- CRUD ----
+export function listWorkflows(folderId) {
+    migrateFromLegacyFormat();
+    const items = readAllWorkflowFiles();
+    if (folderId !== undefined)
+        return items.filter(w => w.folderId === folderId);
+    return items;
 }
 export function getWorkflow(workflowId) {
-    return readJsonFile(workflowFile(workflowId));
+    migrateFromLegacyFormat();
+    return readWorkflowFile(workflowId);
 }
 export function createWorkflow(workflow) {
-    ensureDir(workflowsDir());
-    writeJsonFile(workflowFile(workflow.id), workflow);
-    const index = listWorkflows();
-    index.push(workflow);
-    writeJsonFile(workflowsIndex(), index);
+    ensureDir(workflowDir(workflow.id));
+    writeJsonFile(workflowPath(workflow.id), workflow);
 }
 export function updateWorkflow(workflow) {
-    writeJsonFile(workflowFile(workflow.id), workflow);
-    const index = listWorkflows();
-    const idx = index.findIndex(w => w.id === workflow.id);
-    if (idx !== -1)
-        index[idx] = workflow;
-    writeJsonFile(workflowsIndex(), index);
+    ensureDir(workflowDir(workflow.id));
+    writeJsonFile(workflowPath(workflow.id), workflow);
 }
 export function deleteWorkflow(workflowId) {
-    deleteFile(workflowFile(workflowId));
-    const index = listWorkflows();
-    writeJsonFile(workflowsIndex(), index.filter(w => w.id !== workflowId));
+    const dir = workflowDir(workflowId);
+    if (existsSync(dir))
+        rmSync(dir, { recursive: true, force: true });
+    // Also clean up legacy flat file if it exists
+    const legacy = legacyWorkflowPath(workflowId);
+    if (existsSync(legacy))
+        unlinkSync(legacy);
+}
+// ---- Folders ----
+export function listWorkflowFolders() {
+    const data = readJsonFile(workflowFoldersPath());
+    const folders = data?.folders ?? [];
+    return [...folders].sort((a, b) => a.order - b.order);
+}
+export function createWorkflowFolder(folder) {
+    const folders = listWorkflowFolders();
+    folders.push(folder);
+    writeJsonFile(workflowFoldersPath(), { folders });
+}
+export function updateWorkflowFolder(id, updates) {
+    const folders = listWorkflowFolders();
+    const idx = folders.findIndex(f => f.id === id);
+    if (idx === -1)
+        throw new Error(`Folder ${id} not found`);
+    folders[idx] = { ...folders[idx], ...updates };
+    writeJsonFile(workflowFoldersPath(), { folders });
+}
+export function deleteWorkflowFolder(id) {
+    const folders = listWorkflowFolders();
+    const childIds = collectChildFolderIds(folders, id);
+    const idsToDelete = new Set([id, ...childIds]);
+    const remaining = folders.filter(f => !idsToDelete.has(f.id));
+    writeJsonFile(workflowFoldersPath(), { folders: remaining });
+    // Delete workflows in removed folders
+    const workflows = readAllWorkflowFiles().filter(w => idsToDelete.has(w.folderId ?? ''));
+    for (const wf of workflows)
+        deleteWorkflow(wf.id);
+}
+// ---- Versions ----
+const MAX_VERSIONS = 100;
+export function listVersions(workflowId) {
+    const dir = versionsDir(workflowId);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => {
+        try {
+            return JSON.parse(readFileSync(path.join(dir, f), 'utf-8'));
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter(Boolean)
+        .sort((a, b) => b.createdAt - a.createdAt);
+}
+export function addVersion(workflowId, version) {
+    const dir = versionsDir(workflowId);
+    ensureDir(dir);
+    writeJsonFile(path.join(dir, `${version.id}.json`), version);
+    // Enforce limit
+    const versions = listVersions(workflowId);
+    if (versions.length > MAX_VERSIONS) {
+        versions.slice(MAX_VERSIONS).forEach((v) => {
+            const p = path.join(dir, `${v.id}.json`);
+            if (existsSync(p))
+                unlinkSync(p);
+        });
+    }
+    return version;
+}
+export function getVersion(workflowId, versionId) {
+    const file = path.join(versionsDir(workflowId), `${versionId}.json`);
+    return readJsonFile(file);
+}
+export function deleteVersion(workflowId, versionId) {
+    const file = path.join(versionsDir(workflowId), `${versionId}.json`);
+    if (existsSync(file))
+        unlinkSync(file);
+}
+export function clearVersions(workflowId) {
+    const dir = versionsDir(workflowId);
+    if (!existsSync(dir))
+        return;
+    readdirSync(dir).filter(f => f.endsWith('.json')).forEach(f => unlinkSync(path.join(dir, f)));
+}
+// ---- Execution Logs ----
+const MAX_LOGS = 100;
+export function listExecutionLogs(workflowId) {
+    const dir = executionHistoryDir(workflowId);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir)
+        .filter(f => f.endsWith('.json'))
+        .map(f => {
+        const p = path.join(dir, f);
+        try {
+            return { log: JSON.parse(readFileSync(p, 'utf-8')), mtime: statSync(p).mtimeMs };
+        }
+        catch {
+            return null;
+        }
+    })
+        .filter(Boolean)
+        .sort((a, b) => b.mtime - a.mtime)
+        .map((item) => item.log);
+}
+export function addExecutionLog(workflowId, log) {
+    const dir = executionHistoryDir(workflowId);
+    ensureDir(dir);
+    writeJsonFile(path.join(dir, `${log.id}.json`), log);
+    // Enforce limit
+    const files = readdirSync(dir).filter(f => f.endsWith('.json'));
+    if (files.length > MAX_LOGS) {
+        files.map(f => ({ f, mtime: statSync(path.join(dir, f)).mtimeMs }))
+            .sort((a, b) => b.mtime - a.mtime)
+            .slice(MAX_LOGS)
+            .forEach(item => { try {
+            unlinkSync(path.join(dir, item.f));
+        }
+        catch { /* ignore */ } });
+    }
+    return log;
+}
+export function listAllExecutionLogs(limit = 50) {
+    const dir = workflowsDir();
+    if (!existsSync(dir))
+        return [];
+    const results = [];
+    const wDirs = readdirSync(dir, { withFileTypes: true }).filter(d => d.isDirectory());
+    for (const wDir of wDirs) {
+        const wId = wDir.name;
+        const historyDir = executionHistoryDir(wId);
+        if (!existsSync(historyDir))
+            continue;
+        // Read workflow name for display
+        let workflowName = wId;
+        const wfPath = workflowPath(wId);
+        if (existsSync(wfPath)) {
+            try {
+                workflowName = JSON.parse(readFileSync(wfPath, 'utf-8')).name || wId;
+            }
+            catch { /* ignore */ }
+        }
+        readdirSync(historyDir)
+            .filter(f => f.endsWith('.json'))
+            .forEach(f => {
+            try {
+                const log = JSON.parse(readFileSync(path.join(historyDir, f), 'utf-8'));
+                results.push({ ...log, workflowName });
+            }
+            catch { /* ignore */ }
+        });
+    }
+    return results
+        .sort((a, b) => (b.startedAt || 0) - (a.startedAt || 0))
+        .slice(0, limit);
+}
+export function getExecutionLog(workflowId, logId) {
+    return readJsonFile(path.join(executionHistoryDir(workflowId), `${logId}.json`));
+}
+export function deleteExecutionLog(workflowId, logId) {
+    const file = path.join(executionHistoryDir(workflowId), `${logId}.json`);
+    if (existsSync(file))
+        unlinkSync(file);
+}
+export function clearExecutionLogs(workflowId) {
+    const dir = executionHistoryDir(workflowId);
+    if (!existsSync(dir))
+        return;
+    readdirSync(dir).filter(f => f.endsWith('.json')).forEach(f => unlinkSync(path.join(dir, f)));
+}
+// ---- Staging ----
+export function loadStaging(workflowId) {
+    return readJsonFile(stagingPath(workflowId)) ?? [];
+}
+export function saveStaging(workflowId, nodes) {
+    ensureDir(workflowDir(workflowId));
+    writeJsonFile(stagingPath(workflowId), nodes);
+}
+export function clearStaging(workflowId) {
+    const file = stagingPath(workflowId);
+    if (existsSync(file))
+        unlinkSync(file);
+}
+// ---- Operation History ----
+export function loadOperationHistory(workflowId) {
+    return readJsonFile(operationHistoryPath(workflowId)) ?? [];
+}
+export function saveOperationHistory(workflowId, entries) {
+    ensureDir(workflowDir(workflowId));
+    writeJsonFile(operationHistoryPath(workflowId), entries);
+}
+export function clearOperationHistory(workflowId) {
+    const file = operationHistoryPath(workflowId);
+    if (existsSync(file))
+        unlinkSync(file);
+}
+// ---- Workflow Agent Chat ----
+export function loadChat(workflowId) {
+    return readJsonFile(chatPath(workflowId)) ?? [];
+}
+export function saveChat(workflowId, messages) {
+    ensureDir(workflowDir(workflowId));
+    writeJsonFile(chatPath(workflowId), messages);
+}
+export function clearChat(workflowId) {
+    const file = chatPath(workflowId);
+    if (existsSync(file))
+        unlinkSync(file);
+}
+// ---- Plugin Schemes ----
+export function listPluginSchemes(workflowId, pluginId) {
+    const dir = path.join(pluginConfigsDir(workflowId), pluginId);
+    if (!existsSync(dir))
+        return [];
+    return readdirSync(dir).filter(f => f.endsWith('.json')).map(f => f.replace(/\.json$/, '')).sort();
+}
+export function readPluginScheme(workflowId, pluginId, schemeName) {
+    const file = pluginSchemePath(workflowId, pluginId, schemeName);
+    if (!existsSync(file))
+        throw new Error(`Plugin scheme ${schemeName} not found`);
+    return JSON.parse(readFileSync(file, 'utf-8'));
+}
+export function savePluginScheme(workflowId, pluginId, schemeName, data) {
+    const dir = path.join(pluginConfigsDir(workflowId), pluginId);
+    ensureDir(dir);
+    writeJsonFile(pluginSchemePath(workflowId, pluginId, schemeName), data);
+}
+export function deletePluginScheme(workflowId, pluginId, schemeName) {
+    const file = pluginSchemePath(workflowId, pluginId, schemeName);
+    if (existsSync(file))
+        unlinkSync(file);
+}
+// ---- Internal helpers ----
+function readAllWorkflowFiles() {
+    const dir = workflowsDir();
+    if (!existsSync(dir))
+        return [];
+    const items = [];
+    const entries = readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const file = path.join(dir, entry.name, 'workflow.json');
+        if (!existsSync(file))
+            continue;
+        try {
+            items.push(JSON.parse(readFileSync(file, 'utf-8')));
+        }
+        catch { /* skip broken */ }
+    }
+    return items.sort((a, b) => b.updatedAt - a.updatedAt);
+}
+function readWorkflowFile(workflowId) {
+    const file = workflowPath(workflowId);
+    if (!existsSync(file))
+        return null;
+    try {
+        return JSON.parse(readFileSync(file, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+}
+function collectChildFolderIds(folders, parentId) {
+    const children = folders.filter(f => f.parentId === parentId);
+    return children.reduce((acc, child) => [...acc, child.id, ...collectChildFolderIds(folders, child.id)], []);
 }
+// Need statSync for execution log sorting
+import { statSync } from 'node:fs';
 //# sourceMappingURL=workflow-store.js.map

package/dist/ws/agent-prompt.js

@@ -183,10 +183,12 @@ function formatRuntimeToolsLine(runtimeKind) {
         : runtimeKind === 'codex'
             ? 'Bash, file edits, WebSearch, todo list, MCP tools'
             : runtimeKind === 'langchain'
-                ? 'Agent Spaces function tools'
+                ? 'Agent Spaces function tools and configured MCP tools'
                 : runtimeKind === 'hermes'
                     ? 'Hermes CLI tools and configured skills'
-                    : 'runtime-specific tools exposed by the selected adapter';
+                    : runtimeKind === 'oh-my-pi'
+                        ? 'Oh My Pi built-in tools, discovered extensions, MCP tools, skills, and Agent Spaces function tools'
+                        : 'runtime-specific tools exposed by the selected adapter';
     return `- Runtime tools available through ${runtimeName}: ${tools}`;
 }
 function formatRuntimeName(runtimeKind) {
@@ -199,6 +201,8 @@ function formatRuntimeName(runtimeKind) {
             return 'LangChain';
         case 'hermes':
             return 'Hermes';
+        case 'oh-my-pi':
+            return 'Oh My Pi';
         case 'open-agent-sdk':
             return 'OpenAgent SDK';
         default: