@agent-spaces/server 0.3.67 → 0.4.0

package/dist/routes/agent-sse.js

@@ -6,6 +6,7 @@ import * as workspaceService from '../services/workspace.js';
 import { getThinkingRuntimeConfig } from '../services/llm-model-config.js';
 import { buildAgentPrompt } from '../ws/agent-prompt.js';
 import { wrapOnEventWithHooks } from '../services/hook-engine.js';
+import { buildWorkflowEditorSystemPrompt, createWorkflowEditorFunctionTools } from '../services/builtin-tools/workflow-editor-tools.js';
 const router = Router();
 router.post('/run', async (req, res) => {
     const body = req.body;
@@ -45,13 +46,24 @@ router.post('/run', async (req, res) => {
     const requestedSkills = normalizeSkills(body.skills ?? body.skill) ?? preset.skills;
     const configDir = agentService.getAgentConfigDir(workspaceId, { ...preset, skills: requestedSkills });
     const skills = agentService.getAvailableSkillNames(configDir, requestedSkills);
+    const workflowAgent = normalizeWorkflowAgent(body.workflowAgent);
+    const functionTools = workflowAgent
+        ? createWorkflowEditorFunctionTools({
+            workflow: workflowAgent.workflow,
+            nodeDefinitions: workflowAgent.nodeDefinitions,
+        })
+        : [];
+    const runtimeKind = workflowAgent ? 'langchain' : preset.runtimeKind;
+    const systemPrompt = workflowAgent
+        ? buildWorkflowEditorSystemPrompt(workflowAgent.workflow, workflowAgent.selectedNodes)
+        : body.systemPrompt ?? preset.systemPrompt;
     const output = [];
     const workingDir = agentService.resolveWorkingDir(workspaceId, preset);
     let completed = false;
     prepareSse(res);
     writeSse(res, 'session', { session, workspaceId });
     const runtime = createAgentRuntime({
-        kind: preset.runtimeKind,
+        kind: runtimeKind,
         provider: preset.modelProvider,
         model: preset.modelId,
         apiKey: preset.apiKey,
@@ -66,18 +78,19 @@ router.post('/run', async (req, res) => {
     try {
         agentService.updateStatus(workspaceId, session.id, 'active');
         writeSse(res, 'status', { agentId: session.id, status: 'active' });
-        const result = await runtime.execute(buildAgentPrompt(workspaceId, body.systemPrompt ?? preset.systemPrompt, userPrompt, normalizeMessages(body.messages), {
-            runtimeKind: preset.runtimeKind,
+        const result = await runtime.execute(buildAgentPrompt(workspaceId, systemPrompt, userPrompt, normalizeMessages(body.messages), {
+            runtimeKind,
             mcpServers: Object.keys(mcpServers ?? {}),
             skills,
             boundDirs: workspace.boundDirs,
             workingDir,
-            excludeNativeClaudeMd: preset.runtimeKind === 'claude-code',
-            builtInTools: [],
+            excludeNativeClaudeMd: runtimeKind === 'claude-code',
+            builtInTools: functionTools.map((tool) => ({ name: tool.name, description: tool.description })),
         }), workingDir, {
             maxTurns: normalizeMaxTurns(body.maxTurns),
             mcpServers,
             skills,
+            functionTools,
             configDir,
             sandboxDirs: preset.sandboxDirs,
             userPrompt,
@@ -91,7 +104,7 @@ router.post('/run', async (req, res) => {
         completed = true;
         const displayOutput = output.length ? output : result.output;
         agentService.complete(workspaceId, session.id, result.success ? undefined : result.error, {
-            runtime: preset.runtimeKind,
+            runtime: runtimeKind,
             model: preset.modelId,
             summary: result.summary,
             output: displayOutput,
@@ -116,7 +129,7 @@ router.post('/run', async (req, res) => {
         completed = true;
         const error = err instanceof Error ? err.message : String(err);
         agentService.complete(workspaceId, session.id, error, {
-            runtime: preset.runtimeKind,
+            runtime: runtimeKind,
             model: preset.modelId,
             summary: error,
             output: output.length ? output : [error],
@@ -192,6 +205,56 @@ function normalizeSkills(input) {
 function normalizeMaxTurns(value) {
     return typeof value === 'number' && Number.isFinite(value) && value > 0 ? Math.floor(value) : 100;
 }
+function normalizeWorkflowAgent(input) {
+    if (!input || typeof input !== 'object')
+        return null;
+    if (!isWorkflow(input.workflow))
+        return null;
+    const nodeDefinitions = Array.isArray(input.nodeDefinitions)
+        ? input.nodeDefinitions.filter(isNodeDefinition)
+        : [];
+    if (!nodeDefinitions.length)
+        return null;
+    const selectedNodes = Array.isArray(input.selectedNodes)
+        ? input.selectedNodes.filter(isWorkflowNode)
+        : undefined;
+    return { workflow: input.workflow, nodeDefinitions, selectedNodes };
+}
+function isWorkflow(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.id === 'string'
+        && typeof record.name === 'string'
+        && Array.isArray(record.nodes)
+        && Array.isArray(record.edges)
+        && record.nodes.every(isWorkflowNode);
+}
+function isWorkflowNode(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    const position = record.position;
+    return typeof record.id === 'string'
+        && typeof record.type === 'string'
+        && typeof record.label === 'string'
+        && Boolean(position)
+        && typeof position?.x === 'number'
+        && typeof position?.y === 'number'
+        && typeof record.data === 'object'
+        && record.data !== null
+        && !Array.isArray(record.data);
+}
+function isNodeDefinition(value) {
+    if (!value || typeof value !== 'object' || Array.isArray(value))
+        return false;
+    const record = value;
+    return typeof record.type === 'string'
+        && typeof record.label === 'string'
+        && typeof record.category === 'string'
+        && typeof record.description === 'string'
+        && Array.isArray(record.properties);
+}
 function serializeRuntimeEvent(event) {
     if (event.type === 'tool_use') {
         return {

package/dist/routes/channel.js

@@ -5,6 +5,8 @@ import { broadcastToWorkspace } from '../ws/connection-manager.js';
 import { hasActiveChannelRuns, stopChannelRuns } from '../ws/agent-runner.js';
 import { getToolDetail } from '../services/tool-detail.js';
 import * as issueService from '../services/issue.js';
+import { scheduleChannelTitleGeneration } from '../services/generated-title.js';
+import { stripHtml } from '../ws/html-utils.js';
 const router = Router({ mergeParams: true });
 // GET /api/workspaces/:id/channels
 router.get('/', (req, res) => {
@@ -12,10 +14,20 @@ router.get('/', (req, res) => {
 });
 // POST /api/workspaces/:id/channels
 router.post('/', (req, res) => {
-    const { name, type, members } = req.body;
-    const channel = createChannel(req.params.id, { name: name || 'General', type: type || 'general', members });
+    const name = typeof req.body.name === 'string' ? req.body.name.trim() : '';
+    const titlePrompt = typeof req.body.titlePrompt === 'string' ? req.body.titlePrompt.trim() : '';
+    const { type, members } = req.body;
+    const channel = createChannel(req.params.id, { name, type: type || 'general', members });
     broadcastToWorkspace(req.params.id, 'channel.updated', channel);
     res.status(201).json(channel);
+    if (!name) {
+        scheduleChannelTitleGeneration({
+            workspaceId: req.params.id,
+            channelId: channel.id,
+            requirement: titlePrompt,
+            broadcast: (event, data) => broadcastToWorkspace(req.params.id, event, data),
+        });
+    }
 });
 // PUT /api/workspaces/:id/channels/:channelId
 router.put('/:channelId', (req, res) => {
@@ -119,6 +131,15 @@ router.post('/:channelId/messages', (req, res) => {
     }
     const message = createMessage(id, channelId, { senderId: 'user', content, type, attachments });
     broadcastToWorkspace(id, 'channel.message', message);
+    const channel = getChannel(id, channelId);
+    if (channel && !channel.name.trim()) {
+        scheduleChannelTitleGeneration({
+            workspaceId: id,
+            channelId: channelId,
+            requirement: stripHtml(content),
+            broadcast: (event, data) => broadcastToWorkspace(id, event, data),
+        });
+    }
     res.status(201).json(message);
 });
 // PUT /api/workspaces/:id/channels/:channelId/messages/:messageId

package/dist/routes/chat-run.js

@@ -0,0 +1,191 @@
+import { Router } from 'express';
+import * as chatService from '../services/chat.js';
+import * as agentService from '../services/agent.js';
+import { LangChainRuntime } from '../adapters/langchain-runtime.js';
+import { createCommandFunctionTools, createDatabaseFunctionTools, createKanbanFunctionTools, createWorkflowExecutionFunctionTools, } from '../services/builtin-tools/index.js';
+const router = Router();
+router.post('/agents/:id/run', async (req, res) => {
+    const { id } = req.params;
+    const { content, regenerateFromMessageId } = req.body;
+    const regenerateContext = regenerateFromMessageId
+        ? resolveRegenerateContext(id, regenerateFromMessageId)
+        : null;
+    const trimmedContent = (regenerateContext?.content ?? content)?.trim();
+    if (!trimmedContent) {
+        res.status(400).json({ error: 'content is required' });
+        return;
+    }
+    const agent = chatService.findAgent(id);
+    if (!agent) {
+        res.status(404).json({ error: 'Agent not found' });
+        return;
+    }
+    const baseURL = resolveChatAgentBaseURL(agent);
+    prepareSse(res);
+    if (!baseURL && requiresBaseURL(agent.provider)) {
+        writeSse(res, 'error', {
+            error: `${agent.provider} requires an API Base URL. Edit this chat agent and save the provider API address again.`,
+        });
+        res.end();
+        return;
+    }
+    if (!regenerateContext) {
+        const userMsg = chatService.saveMessage({
+            agentId: id,
+            role: 'user',
+            content: trimmedContent,
+        });
+        writeSse(res, 'message_saved', userMsg);
+    }
+    const config = {
+        kind: 'langchain',
+        provider: agent.provider,
+        model: agent.model,
+        apiKey: agent.apiKey,
+        baseURL,
+    };
+    const runtime = new LangChainRuntime(config);
+    let completed = false;
+    res.on('close', () => {
+        if (!completed && !res.writableEnded)
+            runtime.stop();
+    });
+    try {
+        const historyMessages = regenerateContext?.historyMessages ?? chatService.getRecentMessages(id, 20).slice(0, -1);
+        const historyPrompt = historyMessages
+            .filter(shouldIncludeHistoryMessage)
+            .map((message) => `${message.role === 'user' ? 'User' : 'Assistant'}: ${message.content}`)
+            .join('\n\n');
+        const prompt = historyPrompt
+            ? `${historyPrompt}\n\nUser: ${trimmedContent}\nAssistant:`
+            : trimmedContent;
+        const workingDir = chatService.getAgentWorkingDir(id) || process.cwd();
+        const configDir = chatService.getAgentConfigDir(id) || undefined;
+        const tools = normalizeToolNames(agent.tools);
+        const functionTools = [
+            ...createCommandFunctionTools(id, tools),
+            ...createDatabaseFunctionTools(id, tools),
+            ...createKanbanFunctionTools(id, tools),
+            ...createWorkflowExecutionFunctionTools(tools),
+        ];
+        const result = await runtime.execute(prompt, workingDir, {
+            maxTurns: 100,
+            functionTools,
+            mcpServers: agentService.getMcpServers(agent.mcps),
+            skills: normalizeSkillNames(agent.skills),
+            configDir,
+            systemPrompt: agent.systemPrompt,
+            outputStyle: agent.outputStyle,
+            onEvent: (event) => {
+                writeRuntimeEvent(res, event);
+            },
+        });
+        if (!result.success) {
+            completed = true;
+            writeSse(res, 'error', { error: result.error ?? result.summary });
+            return;
+        }
+        const agentContent = result.output
+            .filter((line) => !line.startsWith('Tool:') && !line.startsWith('[Usage]'))
+            .join('\n')
+            || result.summary;
+        const agentMsg = chatService.saveMessage({
+            agentId: id,
+            role: 'agent',
+            content: agentContent,
+            usage: result.usage,
+        });
+        completed = true;
+        writeSse(res, 'completed', { message: agentMsg, success: result.success, error: result.error });
+    }
+    catch (err) {
+        completed = true;
+        writeSse(res, 'error', { error: err instanceof Error ? err.message : String(err) });
+    }
+    finally {
+        res.end();
+    }
+});
+function prepareSse(res) {
+    res.status(200);
+    res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+    res.setHeader('Cache-Control', 'no-cache, no-transform');
+    res.setHeader('Connection', 'keep-alive');
+    res.setHeader('X-Accel-Buffering', 'no');
+    res.flushHeaders?.();
+    res.socket?.setNoDelay?.(true);
+}
+function writeSse(res, event, data) {
+    res.write(`event: ${event}\n`);
+    res.write(`data: ${JSON.stringify(data)}\n\n`);
+    const flushable = res;
+    if (typeof flushable.flush === 'function')
+        flushable.flush();
+}
+function writeRuntimeEvent(res, event) {
+    switch (event.type) {
+        case 'output':
+            if (!event.line.startsWith('[Usage]'))
+                writeSse(res, 'output', { chunk: event.line });
+            break;
+        case 'reasoning':
+            writeSse(res, 'thinking', { chunk: event.text, status: event.status });
+            break;
+        case 'tool_use':
+            writeSse(res, 'tool_use', { name: event.name, input: event.input });
+            break;
+        case 'tool_result':
+            writeSse(res, 'tool_result', { name: event.toolUseId, result: event.result });
+            break;
+        case 'session':
+        case 'hook_event':
+            break;
+    }
+}
+function shouldIncludeHistoryMessage(message) {
+    return !(message.role === 'agent' && message.content.trim() === 'LangChain execution failed');
+}
+function resolveRegenerateContext(agentId, messageId) {
+    const messages = chatService.listMessages(agentId);
+    const targetIndex = messages.findIndex((message) => message.id === messageId && message.role === 'agent');
+    if (targetIndex === -1)
+        return null;
+    for (let index = targetIndex - 1; index >= 0; index -= 1) {
+        const message = messages[index];
+        if (message?.role === 'user') {
+            return {
+                content: message.content,
+                historyMessages: messages.slice(0, index),
+            };
+        }
+    }
+    return null;
+}
+function resolveChatAgentBaseURL(agent) {
+    return agent.baseURL?.trim() || agent.apiBase?.trim() || undefined;
+}
+function requiresBaseURL(provider) {
+    return provider === 'openai-chat-completions'
+        || provider === 'openai-responses'
+        || provider === 'anthropic-messages'
+        || provider === 'gemini-generate-content';
+}
+function normalizeSkillNames(skills) {
+    if (!Array.isArray(skills))
+        return [];
+    return skills
+        .map((skill) => typeof skill === 'string'
+        ? skill
+        : skill && typeof skill === 'object' && 'name' in skill && typeof skill.name === 'string'
+            ? skill.name
+            : '')
+        .map((skill) => skill.trim())
+        .filter(Boolean);
+}
+function normalizeToolNames(tools) {
+    if (!Array.isArray(tools))
+        return undefined;
+    return tools.filter((tool) => typeof tool === 'string');
+}
+export default router;
+//# sourceMappingURL=chat-run.js.map

package/dist/routes/chat.js

@@ -0,0 +1,142 @@
+import { Router } from 'express';
+import * as svc from '../services/chat.js';
+import * as fileService from '../services/file.js';
+const router = Router();
+// GET /api/chat/agents — list all chat agents
+router.get('/agents', (_req, res) => {
+    try {
+        res.json(svc.listAgents());
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// POST /api/chat/agents — create agent (requires name, provider, model, apiKey)
+router.post('/agents', (req, res) => {
+    const body = req.body;
+    const name = typeof body.name === 'string' ? body.name.trim() : '';
+    const provider = stringValue(body.provider) || stringValue(body.modelProvider);
+    const model = stringValue(body.model) || stringValue(body.modelId);
+    if (!name || !provider || !model) {
+        res.status(400).json({ error: 'name, provider, and model are required' });
+        return;
+    }
+    try {
+        const agent = svc.createAgent(body);
+        res.status(201).json(agent);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// PUT /api/chat/agents/:id — update agent
+router.put('/agents/:id', (req, res) => {
+    const { id } = req.params;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    try {
+        const patch = normalizeChatAgentPatch(req.body);
+        const agent = svc.updateAgent(id, patch);
+        if (!agent) {
+            res.status(404).json({ error: 'Agent not found' });
+            return;
+        }
+        res.json(agent);
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+function normalizeChatAgentPatch(body) {
+    if (!body || typeof body !== 'object' || Array.isArray(body))
+        return {};
+    const patch = { ...body };
+    if (!patch.baseURL && patch.apiBase) {
+        patch.baseURL = patch.apiBase;
+    }
+    delete patch.apiBase;
+    return patch;
+}
+// DELETE /api/chat/agents/:id — delete agent + its messages
+router.delete('/agents/:id', (req, res) => {
+    const { id } = req.params;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    try {
+        const deleted = svc.deleteAgent(id);
+        if (!deleted) {
+            res.status(404).json({ error: 'Agent not found' });
+            return;
+        }
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// GET /api/chat/agents/:id/messages — list messages (?limit=50&before=msgId)
+router.get('/agents/:id/messages', (req, res) => {
+    const { id } = req.params;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    try {
+        const agent = svc.findAgent(id);
+        if (!agent) {
+            res.status(404).json({ error: 'Agent not found' });
+            return;
+        }
+        const limit = req.query.limit ? parseInt(req.query.limit, 10) : undefined;
+        const before = req.query.before;
+        res.json(svc.listMessages(id, limit, before));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// DELETE /api/chat/agents/:id/messages — clear messages
+router.delete('/agents/:id/messages', (req, res) => {
+    const { id } = req.params;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    try {
+        svc.clearMessages(id);
+        res.status(204).send();
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+// GET /api/chat/agents/:id/workspace/tree - read chat agent working directory
+router.get('/agents/:id/workspace/tree', async (req, res) => {
+    const { id } = req.params;
+    if (!id) {
+        res.status(400).json({ error: 'id is required' });
+        return;
+    }
+    try {
+        const workspace = svc.getAgentWorkspace(id);
+        if (!workspace) {
+            res.status(404).json({ error: 'Agent workspace not found' });
+            return;
+        }
+        const relPath = typeof req.query.path === 'string' ? req.query.path : '';
+        const depth = req.query.depth ? Number(req.query.depth) : Infinity;
+        res.json(await fileService.readTree(workspace, relPath, depth));
+    }
+    catch (error) {
+        res.status(500).json({ error: error.message });
+    }
+});
+function stringValue(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+export default router;
+//# sourceMappingURL=chat.js.map

package/dist/routes/command.js

@@ -104,5 +104,21 @@ router.post('/:commandId/stop', (req, res) => {
         res.status(400).json({ error: error.message });
     }
 });
+router.post('/:commandId/restart', (req, res) => {
+    const { id: workspaceId, commandId } = req.params;
+    if (!workspaceId || !commandId) {
+        res.status(400).json({ error: 'workspaceId and commandId required' });
+        return;
+    }
+    try {
+        const sessionId = processManager.restartCommand(workspaceId, commandId);
+        console.log(`[command] POST restart: workspace=${workspaceId} command=${commandId} -> session=${sessionId}`);
+        res.json({ sessionId });
+    }
+    catch (error) {
+        console.error(`[command] POST restart error: workspace=${workspaceId} command=${commandId}`, error.message);
+        res.status(400).json({ error: error.message });
+    }
+});
 export default router;
 //# sourceMappingURL=command.js.map