@agent-spaces/server 0.3.65 → 0.4.0

package/dist/services/agent.js

@@ -11,7 +11,13 @@ import { extractUsageFromOutput } from '../storage/usage.js';
 const DEFAULT_AGENT_ROLE = 'agent';
 export const AGENT_GENERATOR_PRESET_ID = 'agent-generator';
 export const AGENT_COMMIT_PRESET_ID = 'commit-agent';
-const VALID_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex', 'langchain'];
+export const AGENT_TITLE_GENERATOR_PRESET_ID = 'title-generator';
+const BUILT_IN_AGENT_IDS = [
+    AGENT_GENERATOR_PRESET_ID,
+    AGENT_COMMIT_PRESET_ID,
+    AGENT_TITLE_GENERATOR_PRESET_ID,
+];
+const VALID_RUNTIME_KINDS = ['open-agent-sdk', 'claude-code', 'codex', 'langchain', 'hermes', 'oh-my-pi'];
 const VALID_TOOL_NAMES = new Set(BUILT_IN_AGENT_TOOLS.map((tool) => tool.name));
 const CLAUDE_BUILT_IN_DIRS = ['agents', 'commands'];
 const ANTHROPIC_BRIDGE_PROVIDERS = [
@@ -27,18 +33,12 @@ export function isValidRole(role) {
 export function listTemplates() {
     const root = getGlobalAgentTemplatesDir();
     if (!existsSync(root))
-        return [getDefaultAgentGeneratorPreset(), getDefaultCommitAgentPreset()];
+        return getDefaultBuiltInAgentPresets();
     const templates = readdirSync(root, { withFileTypes: true })
         .filter((entry) => entry.isDirectory())
         .map((entry) => readAgentTemplate(entry.name))
         .filter((template) => Boolean(template));
-    if (!templates.some((template) => template.id === AGENT_GENERATOR_PRESET_ID)) {
-        templates.unshift(getDefaultAgentGeneratorPreset());
-    }
-    if (!templates.some((template) => template.id === AGENT_COMMIT_PRESET_ID)) {
-        templates.unshift(getDefaultCommitAgentPreset());
-    }
-    return templates;
+    return withBuiltInTemplatesFirst(templates);
 }
 export async function testConnection(workspaceId, data) {
     if (workspaceId) {
@@ -279,8 +279,11 @@ export function createPreset(_workspaceId, data) {
         skills: normalizeSkillNames(data.skills),
         tools: normalizeToolNames(data.tools ?? BUILT_IN_AGENT_TOOLS.map((tool) => tool.name)),
         systemPrompt: data.systemPrompt || '',
+        outputStyle: data.outputStyle,
         temperature: data.temperature ?? 0.3,
         maxTokens: data.maxTokens ?? 4096,
+        avatarUrl: data.avatarUrl,
+        icon: data.icon,
         sandboxDirs: data.sandboxDirs,
         maxRetries: data.maxRetries,
         templateId: data.templateId,
@@ -316,12 +319,8 @@ export function updatePreset(_workspaceId, presetId, data) {
     return updated;
 }
 export function getAllowedTools(mcps) {
-    if (!mcps)
-        return undefined;
-    const servers = mcps.mcpServers;
-    if (!servers || typeof servers !== 'object' || Array.isArray(servers))
-        return undefined;
-    return Object.keys(servers);
+    const servers = getMcpServers(mcps);
+    return servers ? Object.keys(servers) : undefined;
 }
 export function getMcpServers(mcps) {
     if (!mcps)
@@ -329,7 +328,11 @@ export function getMcpServers(mcps) {
     const servers = mcps.mcpServers;
     if (!servers || typeof servers !== 'object' || Array.isArray(servers))
         return undefined;
-    return servers;
+    const resolved = Object.fromEntries(Object.entries(servers).flatMap(([name, server]) => {
+        const config = getRunnableMcpServerConfig(server) ?? readStoredMcpServerConfig(name);
+        return config ? [[name, config]] : [];
+    }));
+    return Object.keys(resolved).length > 0 ? resolved : undefined;
 }
 export function getAgentConfigDir(workspaceId, preset) {
     const ws = getWorkspace(workspaceId);
@@ -362,13 +365,13 @@ export function getAvailableSkillNames(agentDir, skills) {
         if (!skill)
             return false;
         const skillsBase = join(agentDir, 'skills');
-        // Check folder structure first, then flat .md
-        const skillFolder = join(skillsBase, skill);
-        if (existsSync(skillFolder) && statSync(skillFolder).isDirectory()) {
-            return readdirSync(skillFolder).some((f) => f.endsWith('.md'));
-        }
-        const skillFile = join(skillsBase, `${skill}.md`);
-        return existsSync(skillFile) && statSync(skillFile).size > 0;
+        if (hasReadableSkillSource(skillsBase, skill))
+            return true;
+        const globalSkillFile = join(getDataDir(), 'skills', skill, 'SKILL.md');
+        if (existsSync(globalSkillFile) && statSync(globalSkillFile).size > 0)
+            return true;
+        const globalLegacySkillFile = join(getDataDir(), 'skills', `${skill}.md`);
+        return existsSync(globalLegacySkillFile) && statSync(globalLegacySkillFile).size > 0;
     });
 }
 export function resolveWorkingDir(workspaceId, preset) {
@@ -423,6 +426,31 @@ function normalizeMcpConfig(mcps) {
         return {};
     return mcps;
 }
+function getRunnableMcpServerConfig(server) {
+    if (!server || typeof server !== 'object' || Array.isArray(server))
+        return null;
+    const record = server;
+    if (typeof record.command === 'string' && record.command.trim())
+        return record;
+    if (typeof record.url === 'string' && record.url.trim())
+        return record;
+    return null;
+}
+function readStoredMcpServerConfig(name) {
+    const filePath = join(getDataDir(), 'mcps', `${sanitizeMcpName(name)}.json`);
+    if (!existsSync(filePath))
+        return null;
+    try {
+        const parsed = JSON.parse(readFileSync(filePath, 'utf-8'));
+        return getRunnableMcpServerConfig(parsed.config);
+    }
+    catch {
+        return null;
+    }
+}
+function sanitizeMcpName(name) {
+    return name.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'mcp-server';
+}
 function normalizeModelProvider(provider) {
     return provider || undefined;
 }
@@ -565,10 +593,24 @@ function ensureWorkspaceAgentCopy(preset, agentspaceDir) {
             && statSync(sourceBuiltInDir).isDirectory()
             && countFiles(sourceBuiltInDir) > countFiles(targetBuiltInDir);
     });
-    if (!missingRequiredFile && !missingBuiltInDir)
+    const missingSkill = (preset.skills ?? []).some((skill) => {
+        const skillName = skill.replace(/\.md$/i, '');
+        const targetSkillsDir = join(workspaceAgentDir, 'skills');
+        return !hasReadableSkillSource(targetSkillsDir, skillName);
+    });
+    if (!missingRequiredFile && !missingBuiltInDir && !missingSkill)
         return;
     writeWorkspaceAgentCopy(preset, agentspaceDir);
 }
+function hasReadableSkillSource(skillsDir, skillName) {
+    const skillDir = join(skillsDir, skillName);
+    const skillFile = join(skillDir, 'SKILL.md');
+    if (existsSync(skillDir) && statSync(skillDir).isDirectory()) {
+        return existsSync(skillFile) && statSync(skillFile).size > 0;
+    }
+    const legacySkillFile = join(skillsDir, `${skillName}.md`);
+    return existsSync(legacySkillFile) && statSync(legacySkillFile).size > 0;
+}
 function countFiles(dir) {
     if (!existsSync(dir) || !statSync(dir).isDirectory())
         return 0;
@@ -582,19 +624,37 @@ function countFiles(dir) {
 export function readAgentTemplate(agentId) {
     const filePath = join(getGlobalAgentTemplateDir(agentId), 'agent.json');
     if (!existsSync(filePath)) {
-        return agentId === AGENT_GENERATOR_PRESET_ID ? getDefaultAgentGeneratorPreset()
-            : agentId === AGENT_COMMIT_PRESET_ID ? getDefaultCommitAgentPreset()
-                : null;
+        return getDefaultBuiltInAgentPreset(agentId);
     }
     try {
         return JSON.parse(readFileSync(filePath, 'utf-8'));
     }
     catch {
-        return agentId === AGENT_GENERATOR_PRESET_ID ? getDefaultAgentGeneratorPreset()
-            : agentId === AGENT_COMMIT_PRESET_ID ? getDefaultCommitAgentPreset()
-                : null;
+        return getDefaultBuiltInAgentPreset(agentId);
     }
 }
+function getDefaultBuiltInAgentPresets() {
+    return [
+        getDefaultAgentGeneratorPreset(),
+        getDefaultCommitAgentPreset(),
+        getDefaultTitleGeneratorPreset(),
+    ];
+}
+function getDefaultBuiltInAgentPreset(agentId) {
+    if (agentId === AGENT_GENERATOR_PRESET_ID)
+        return getDefaultAgentGeneratorPreset();
+    if (agentId === AGENT_COMMIT_PRESET_ID)
+        return getDefaultCommitAgentPreset();
+    if (agentId === AGENT_TITLE_GENERATOR_PRESET_ID)
+        return getDefaultTitleGeneratorPreset();
+    return null;
+}
+function withBuiltInTemplatesFirst(templates) {
+    const byId = new Map(templates.map((template) => [template.id, template]));
+    const builtIns = getDefaultBuiltInAgentPresets().map((preset) => byId.get(preset.id) ?? preset);
+    const custom = templates.filter((template) => !BUILT_IN_AGENT_IDS.includes(template.id));
+    return [...builtIns, ...custom];
+}
 function getDefaultAgentGeneratorPreset() {
     return {
         id: AGENT_GENERATOR_PRESET_ID,
@@ -658,15 +718,44 @@ export function getDefaultCommitAgentPreset() {
         enabled: true,
     };
 }
+export function getDefaultTitleGeneratorPreset() {
+    return {
+        id: AGENT_TITLE_GENERATOR_PRESET_ID,
+        name: 'Title Generator',
+        role: 'agent',
+        description: 'Generate short titles for channels and issues from user requirements.',
+        runtimeKind: 'claude-code',
+        modelProvider: undefined,
+        modelId: '',
+        apiBase: '',
+        apiKey: '',
+        workingDir: '',
+        mcps: {},
+        skills: [],
+        tools: [],
+        systemPrompt: [
+            'You generate objective scene titles for Agent Spaces channels and issues.',
+            'Return exactly one title and nothing else.',
+            'The title must describe the scenario, task, or intent objectively.',
+            'Do not include a speaking subject, assistant identity, user identity, first-person wording, second-person wording, greetings, replies, questions, or conversational text.',
+            'For Chinese, prefer a short noun phrase ending with 场景, 任务, 问题, 需求, 讨论, or 分析 when appropriate.',
+            'Examples: user says "你好" -> "打招呼场景"; user says "帮我修复登录报错" -> "登录报错修复"; user says "分析这段代码" -> "代码分析任务".',
+            'Use the same language as the user request when it is clear.',
+            'Keep the title under 20 Chinese characters or under 8 English words.',
+            'Do not use quotes, markdown, punctuation-only endings, prefixes, explanations, or multiple options.',
+        ].join(' '),
+        temperature: 0.2,
+        maxTokens: 64,
+        enabled: true,
+    };
+}
 function sanitizeMarkdownFilename(name) {
     const raw = basename(name).replace(/\.md$/i, '');
     const safe = raw.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '') || 'skill';
     return `${safe}.md`;
 }
 export function deletePreset(workspaceId, presetId) {
-    if (presetId === AGENT_GENERATOR_PRESET_ID)
-        return false;
-    if (presetId === AGENT_COMMIT_PRESET_ID)
+    if (BUILT_IN_AGENT_IDS.includes(presetId))
         return false;
     const ws = getWorkspace(workspaceId);
     if (!ws)
@@ -755,9 +844,7 @@ export function updateGlobalPreset(presetId, data) {
     return updated;
 }
 export function deleteGlobalPreset(presetId) {
-    if (presetId === AGENT_GENERATOR_PRESET_ID)
-        return false;
-    if (presetId === AGENT_COMMIT_PRESET_ID)
+    if (BUILT_IN_AGENT_IDS.includes(presetId))
         return false;
     const templateDir = getGlobalAgentTemplateDir(presetId);
     if (!existsSync(templateDir))

package/dist/services/ai-text.js

@@ -0,0 +1,185 @@
+export async function requestAiText(config, input) {
+    const provider = config.modelProvider ?? inferProvider(config.apiBase);
+    if (provider === 'anthropic-messages')
+        return requestAnthropic(config, input.systemPrompt, input.userPrompt);
+    if (provider === 'gemini-generate-content')
+        return requestGemini(config, input.systemPrompt, input.userPrompt);
+    return requestOpenAICompatible(config, input.systemPrompt, input.userPrompt, provider === 'openai-responses' || provider === 'openai-responses-to-anthropic-messages');
+}
+export function maskAiTextUrl(url) {
+    if (!url)
+        return undefined;
+    try {
+        const parsed = new URL(url);
+        return `${parsed.origin}${parsed.pathname}`;
+    }
+    catch {
+        return url.slice(0, 80);
+    }
+}
+async function requestOpenAICompatible(config, systemPrompt, userPrompt, useResponsesApi) {
+    const response = await fetch(joinUrl(config.apiBase, useResponsesApi ? '/responses' : '/chat/completions'), {
+        method: 'POST',
+        headers: {
+            Authorization: `Bearer ${config.apiKey}`,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(useResponsesApi
+            ? {
+                model: config.modelId,
+                input: `${systemPrompt}\n\n${userPrompt}`,
+                temperature: config.temperature ?? 0.2,
+                max_output_tokens: config.maxTokens ?? 1024,
+            }
+            : {
+                model: config.modelId,
+                messages: [
+                    { role: 'system', content: systemPrompt },
+                    { role: 'user', content: userPrompt },
+                ],
+                temperature: config.temperature ?? 0.2,
+                max_tokens: config.maxTokens ?? 1024,
+            }),
+    });
+    const body = await readResponseBody(response);
+    if (!response.ok || body.error)
+        throw new Error(body.error || `AI text request failed with status ${response.status}`);
+    return body.text;
+}
+async function requestAnthropic(config, systemPrompt, userPrompt) {
+    const response = await fetch(getAnthropicMessagesUrl(config.apiBase), {
+        method: 'POST',
+        headers: {
+            'x-api-key': config.apiKey,
+            'anthropic-version': '2023-06-01',
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            model: config.modelId,
+            system: systemPrompt,
+            messages: [{ role: 'user', content: userPrompt }],
+            max_tokens: config.maxTokens ?? 1024,
+            temperature: config.temperature ?? 0.2,
+        }),
+    });
+    const body = await readResponseBody(response);
+    if (!response.ok || body.error)
+        throw new Error(body.error || `AI text request failed with status ${response.status}`);
+    return body.text;
+}
+async function requestGemini(config, systemPrompt, userPrompt) {
+    const response = await fetch(joinUrl(config.apiBase, `/models/${encodeURIComponent(config.modelId)}:generateContent`), {
+        method: 'POST',
+        headers: {
+            'x-goog-api-key': config.apiKey,
+            'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+            systemInstruction: { parts: [{ text: systemPrompt }] },
+            contents: [{ role: 'user', parts: [{ text: userPrompt }] }],
+            generationConfig: {
+                temperature: config.temperature ?? 0.2,
+                maxOutputTokens: config.maxTokens ?? 1024,
+            },
+        }),
+    });
+    const body = await readResponseBody(response);
+    if (!response.ok || body.error)
+        throw new Error(body.error || `AI text request failed with status ${response.status}`);
+    return body.text;
+}
+async function readResponseBody(response) {
+    const raw = await response.text();
+    if (!raw)
+        return { text: '' };
+    try {
+        const json = JSON.parse(raw);
+        return {
+            text: extractText(json),
+            error: extractError(json),
+        };
+    }
+    catch {
+        return { text: raw };
+    }
+}
+function extractText(json) {
+    const outputText = json.output_text;
+    if (typeof outputText === 'string')
+        return outputText;
+    const output = Array.isArray(json.output) ? json.output : [];
+    const responseOutputText = output
+        .flatMap((item) => Array.isArray(item.content) ? item.content : [])
+        .map((part) => typeof part.text === 'string' ? part.text : '')
+        .filter(Boolean)
+        .join('\n');
+    if (responseOutputText)
+        return responseOutputText;
+    const choices = Array.isArray(json.choices) ? json.choices : [];
+    const firstChoice = choices[0];
+    if (typeof firstChoice?.text === 'string')
+        return firstChoice.text;
+    const message = firstChoice?.message;
+    if (typeof message?.content === 'string')
+        return message.content;
+    if (Array.isArray(message?.content)) {
+        const messageText = message.content
+            .map((part) => typeof part.text === 'string' ? part.text : '')
+            .filter(Boolean)
+            .join('\n');
+        if (messageText)
+            return messageText;
+    }
+    const content = Array.isArray(json.content) ? json.content : [];
+    const anthropicText = content
+        .map((part) => typeof part.text === 'string' ? part.text : '')
+        .filter(Boolean)
+        .join('\n');
+    if (anthropicText)
+        return anthropicText;
+    const candidates = Array.isArray(json.candidates) ? json.candidates : [];
+    const firstCandidate = candidates[0];
+    const parts = (firstCandidate?.content?.parts ?? []);
+    return parts
+        .map((part) => typeof part.text === 'string' ? part.text : '')
+        .filter(Boolean)
+        .join('\n');
+}
+function extractError(json) {
+    if (json.success === false) {
+        return typeof json.msg === 'string' ? json.msg : 'Provider returned success=false';
+    }
+    const error = json.error;
+    if (typeof error === 'string')
+        return error;
+    if (error && typeof error === 'object') {
+        const message = error.message;
+        if (typeof message === 'string')
+            return message;
+    }
+    return typeof json.message === 'string' ? json.message : undefined;
+}
+function inferProvider(apiBase) {
+    if (apiBase?.includes('anthropic.com'))
+        return 'anthropic-messages';
+    if (apiBase?.includes('generativelanguage.googleapis.com'))
+        return 'gemini-generate-content';
+    return 'openai-chat-completions';
+}
+function joinUrl(base, path) {
+    return `${base.replace(/\/+$/, '')}${path}`;
+}
+function getAnthropicMessagesUrl(apiBase) {
+    try {
+        const url = new URL(apiBase);
+        if (url.pathname.endsWith('/messages'))
+            return apiBase;
+        if (url.hostname === 'api.anthropic.com')
+            return joinUrl(apiBase, '/messages');
+        return joinUrl(apiBase, '/v1/messages');
+    }
+    catch {
+        return apiBase;
+    }
+}
+//# sourceMappingURL=ai-text.js.map

package/dist/services/builtin-tools/index.js

@@ -2,4 +2,5 @@ export { createIssueFunctionTools, isBuiltInIssueToolName } from './issue-tools.
 export { createCommandFunctionTools } from './command-tools.js';
 export { createDatabaseFunctionTools } from './database-tools.js';
 export { createKanbanFunctionTools } from './kanban-tools.js';
+export { createWorkflowExecutionFunctionTools, setWorkflowExecutionManager } from './workflow-exec-tools.js';
 //# sourceMappingURL=index.js.map