@agent-spaces/server 0.3.65 → 0.4.0

package/dist/adapters/langchain-runtime.js

@@ -1,6 +1,10 @@
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { MultiServerMCPClient } from '@langchain/mcp-adapters';
 import { createAgent, initChatModel, tool } from 'langchain';
 import { z } from 'zod';
 import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-types.js';
+const DEFAULT_DATA_DIR = join(process.env.HOME || '~', '.agent-spaces-data');
 /**
  * Runtime backed by LangChain.js.
  * Uses LangChain's provider-neutral createAgent API and adapts Agent Spaces tools.
@@ -8,6 +12,7 @@ import { appendOutputStyleToPrompt, summarizeResult } from './agent-runtime-type
 export class LangChainRuntime {
     config;
     abortController = null;
+    static nextRunId = 1;
     constructor(config = {}) {
         this.config = config;
     }
@@ -16,23 +21,58 @@ export class LangChainRuntime {
         const output = [];
         const cwd = workingDir || process.cwd();
         const startTime = Date.now();
-        const d = (msg) => console.log(`[langchain] ${msg}`);
-        const model = buildModelIdentifier(this.config);
-        d(`starting | cwd=${cwd} provider=${this.config.provider ?? 'auto'} model=${model} baseURL=${this.config.baseURL ?? 'default'} maxTurns=${options?.maxTurns ?? '∞'} tools=${options?.functionTools?.map((runtimeTool) => runtimeTool.name).join(',') || '-'} sandboxDirs=${options?.sandboxDirs?.join(',') ?? '-'}`);
-        d(`prompt: ${prompt.slice(0, 300)}${prompt.length > 300 ? '...' : ''}`);
+        const runId = LangChainRuntime.nextRunId++;
+        const d = (msg) => console.log(`[langchain:${runId}] ${msg}`);
+        const modelSettings = resolveLangChainModelSettings(this.config);
+        const model = modelSettings.modelIdentifier;
+        let mcpClient;
+        const skillPrompts = loadConfiguredSkillPrompts(options?.configDir, options?.skills);
+        d(`starting | cwd=${cwd} provider=${this.config.provider ?? 'auto'} langchainProvider=${modelSettings.provider ?? 'auto'} model=${model} baseURL=${this.config.baseURL ?? 'default'} apiKey=${this.config.apiKey ? 'set' : 'unset'} maxTurns=${options?.maxTurns ?? '∞'} tools=${options?.functionTools?.map((runtimeTool) => runtimeTool.name).join(',') || '-'} mcpServers=${Object.keys(options?.mcpServers ?? {}).join(',') || '-'} skills=${skillPrompts.map((skill) => skill.name).join(',') || '-'} sandboxDirs=${options?.sandboxDirs?.join(',') ?? '-'}`);
+        d(`options | ${summarizeOptionsForLog(options)}`);
+        d(`model config | ${summarizeForLog(maskSensitiveConfig(buildModelConfig(this.config)), 1000)}`);
+        d(`provider env | ${summarizeEnvForLog(buildProviderEnv(this.config, modelSettings.provider))}`);
+        if (modelSettings.providerCorrectionReason)
+            d(`provider adjusted | ${modelSettings.providerCorrectionReason}`);
+        d(`prompt | chars=${prompt.length} preview=${truncateForLog(prompt, 1000)}`);
+        if (skillPrompts.length) {
+            d(`skills loaded | ${skillPrompts.map((skill) => `${skill.name}:${skill.content.length}chars`).join(',')}`);
+        }
+        else if (options?.skills?.length) {
+            d(`skills requested but not loaded | requested=${options.skills.join(',')}`);
+        }
         try {
-            const chatModel = await withTemporaryEnv(buildProviderEnv(this.config), () => initChatModel(model, buildModelConfig(this.config)));
+            d('initializing chat model');
+            const chatModel = await withTemporaryEnv(buildProviderEnv(this.config, modelSettings.provider), () => initChatModel(model, buildModelConfig(this.config)));
+            d(`chat model initialized | type=${getObjectTypeName(chatModel)}`);
+            mcpClient = createLangChainMcpClient(options?.mcpServers, output, options, d);
+            d(`MCP client ${mcpClient ? 'created' : 'not created'}`);
+            const mcpTools = mcpClient ? await mcpClient.getTools() : [];
+            if (mcpClient)
+                d(`resolved MCP tools | servers=${Object.keys(options?.mcpServers ?? {}).join(',') || '-'} count=${mcpTools.length} tools=${mcpTools.map((mcpTool) => mcpTool.name).join(',') || '-'}`);
+            const runtimeTools = buildLangChainTools(options?.functionTools, output, options, d);
+            d(`creating agent | runtimeTools=${runtimeTools.length} mcpTools=${mcpTools.length} systemPrompt=${options?.systemPrompt ? `${options.systemPrompt.length}chars` : '-'} outputStyle=${options?.outputStyle ?? '-'}`);
             const agent = createAgent({
                 model: chatModel,
-                tools: buildLangChainTools(options?.functionTools, output, options),
+                tools: [
+                    ...runtimeTools,
+                    ...mcpTools,
+                ],
                 systemPrompt: options?.systemPrompt,
             });
-            const result = await agent.invoke({ messages: [{ role: 'user', content: appendOutputStyleToPrompt(prompt, options?.outputStyle) }] }, {
+            d(`agent created | type=${getObjectTypeName(agent)}`);
+            const finalPrompt = appendOutputStyleToPrompt(injectSkillPrompts(prompt, skillPrompts), options?.outputStyle);
+            d(`final prompt | chars=${finalPrompt.length} skillCount=${skillPrompts.length} outputStyle=${options?.outputStyle ?? '-'} preview=${truncateForLog(finalPrompt, 1200)}`);
+            const recursionLimit = options?.maxTurns ? Math.max(2, options.maxTurns * 2 + 1) : undefined;
+            d(`invoking agent | recursionLimit=${recursionLimit ?? '-'} aborted=${this.abortController?.signal.aborted ? 'yes' : 'no'}`);
+            const result = await agent.invoke({ messages: [{ role: 'user', content: finalPrompt }] }, {
                 signal: this.abortController?.signal,
-                recursionLimit: options?.maxTurns ? Math.max(2, options.maxTurns * 2 + 1) : undefined,
+                recursionLimit,
             });
+            d(`agent result | ${summarizeAgentResultForLog(result)}`);
             const text = extractFinalText(result);
             const usage = extractUsage(result);
+            d(`final text | chars=${text.length} preview=${truncateForLog(text, 1200) || '-'}`);
+            d(`usage | ${usage ? summarizeForLog(usage, 500) : '-'}`);
             if (text) {
                 output.push(text);
                 options?.onEvent?.({ type: 'output', line: text });
@@ -43,7 +83,7 @@ export class LangChainRuntime {
                 options?.onEvent?.({ type: 'output', line: usageLine });
             }
             const elapsed = Date.now() - startTime;
-            d(`done ${elapsed}ms | tokens=${usage?.totalTokens ?? 'unknown'}`);
+            d(`done ${elapsed}ms | outputLines=${output.length} tokens=${usage?.totalTokens ?? 'unknown'}`);
             return {
                 success: true,
                 summary: summarizeResult(text),
@@ -55,41 +95,146 @@ export class LangChainRuntime {
         catch (err) {
             const elapsed = Date.now() - startTime;
             const message = err instanceof Error ? err.message : String(err);
-            d(`failed ${elapsed}ms | ${message}`);
+            d(`failed ${elapsed}ms | name=${err instanceof Error ? err.name : typeof err} message=${truncateForLog(message, 1000)} outputLines=${output.length}`);
             if (err instanceof Error && err.stack)
                 console.error(err.stack);
             return { success: false, summary: 'LangChain execution failed', artifacts: [], error: message, output };
         }
         finally {
+            if (mcpClient) {
+                d('closing MCP client');
+                try {
+                    await mcpClient.close();
+                    d('MCP client closed');
+                }
+                catch (err) {
+                    d(`MCP client close failed | ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
             this.abortController = null;
+            d('runtime reset');
         }
     }
     stop() {
         this.abortController?.abort();
     }
 }
-function buildLangChainTools(functionTools, output, options) {
+export function buildLangChainPromptWithSkills(prompt, agentDir, skills, outputStyle) {
+    return appendOutputStyleToPrompt(injectSkillPrompts(prompt, loadConfiguredSkillPrompts(agentDir, skills)), outputStyle);
+}
+function injectSkillPrompts(prompt, skills) {
+    if (!skills.length)
+        return prompt;
+    return [
+        prompt.trimEnd(),
+        '',
+        'Configured skill instructions:',
+        `Enabled skill names: ${skills.map((skill) => skill.name).join(', ')}`,
+        'These are configured skills for this run, even if a skill body looks like a design note, plan, or reference document.',
+        'If the user asks what skills are available, answer from the enabled skill names above. Do not say that no skills are available when this list is non-empty.',
+        'Follow the skill contents below when they are relevant to the user request.',
+        '',
+        ...skills.flatMap((skill) => [
+            `## Skill: ${skill.name}`,
+            '',
+            skill.content,
+            '',
+        ]),
+    ].join('\n').trimEnd();
+}
+function loadConfiguredSkillPrompts(agentDir, skills) {
+    if (!Array.isArray(skills))
+        return [];
+    return skills.flatMap((rawSkill) => {
+        const skillName = sanitizeSkillName(rawSkill);
+        if (!skillName)
+            return [];
+        const skillFile = resolveSkillFile(agentDir, skillName);
+        if (!skillFile)
+            return [];
+        const source = readFileSync(skillFile, 'utf-8');
+        const parsed = parseSkillMarkdown(source);
+        const content = parsed.body || source.trim();
+        if (!content)
+            return [];
+        return [{ name: sanitizeSkillName(parsed.meta.name) || skillName, content }];
+    });
+}
+function resolveSkillFile(agentDir, skillName) {
+    const candidates = [
+        ...(agentDir ? [
+            join(agentDir, 'skills', skillName, 'SKILL.md'),
+            join(agentDir, 'skills', `${skillName}.md`),
+        ] : []),
+        join(getDataDir(), 'skills', skillName, 'SKILL.md'),
+        join(getDataDir(), 'skills', `${skillName}.md`),
+    ];
+    return candidates.find((file) => existsSync(file) && statSync(file).size > 0);
+}
+function getDataDir() {
+    return process.env.AGENT_SPACES_DATA_DIR || DEFAULT_DATA_DIR;
+}
+function parseSkillMarkdown(source) {
+    const match = source.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?/);
+    if (!match)
+        return { meta: {}, body: source.trim() };
+    const meta = {};
+    for (const line of match[1].split(/\r?\n/)) {
+        const parsed = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!parsed)
+            continue;
+        meta[parsed[1]] = parsed[2].trim().replace(/^['"]|['"]$/g, '');
+    }
+    return { meta, body: source.slice(match[0].length).trim() };
+}
+function sanitizeSkillName(name) {
+    const raw = basename(name ?? '').replace(/\.md$/i, '').trim();
+    return raw.replace(/[^a-zA-Z0-9._-]+/g, '-').replace(/^-+|-+$/g, '');
+}
+function buildLangChainTools(functionTools, output, options, log) {
     if (!functionTools?.length)
         return [];
     return functionTools.map((runtimeTool) => tool(async (input) => {
+        const startedAt = Date.now();
         const line = `Tool: ${runtimeTool.name} input=${JSON.stringify(input)}`;
+        log(`tool use | source=function name=${runtimeTool.name} descriptionChars=${runtimeTool.description.length} input=${summarizeForLog(input, 800)}`);
         output.push(line);
         options?.onEvent?.({ type: 'tool_use', id: runtimeTool.name, name: runtimeTool.name, input, line });
-        const result = await runtimeTool.execute(input);
-        options?.onEvent?.({ type: 'tool_result', toolUseId: runtimeTool.name, result });
-        return result;
+        try {
+            const result = await runtimeTool.execute(input);
+            log(`tool result | source=function name=${runtimeTool.name} elapsedMs=${Date.now() - startedAt} output=${summarizeForLog(result, 1000)}`);
+            options?.onEvent?.({ type: 'tool_result', toolUseId: runtimeTool.name, result });
+            return stringifyToolResult(result);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            log(`tool error | source=function name=${runtimeTool.name} elapsedMs=${Date.now() - startedAt} error=${truncateForLog(message, 1000)}`);
+            if (err instanceof Error && err.stack)
+                console.error(err.stack);
+            throw err;
+        }
     }, {
         name: runtimeTool.name,
         description: runtimeTool.description,
         schema: z.object({}).passthrough(),
     }));
 }
-function buildModelIdentifier(config) {
+export function resolveLangChainModelSettings(config) {
     const model = config.model || 'gpt-4o-mini';
-    const provider = normalizeLangChainProvider(config.provider);
-    if (!provider || model.includes(':'))
-        return model;
-    return `${provider}:${model}`;
+    const configuredProvider = normalizeLangChainProvider(config.provider);
+    const inferredProvider = inferLangChainProviderFromBaseURL(config.baseURL);
+    const provider = configuredProvider === 'anthropic' && inferredProvider === 'openai'
+        ? inferredProvider
+        : configuredProvider;
+    const plainModel = provider ? stripLangChainProviderPrefix(model) : model;
+    const providerCorrectionReason = provider !== configuredProvider
+        ? `baseURL=${config.baseURL} is OpenAI-compatible, using ${provider} instead of ${configuredProvider}`
+        : undefined;
+    return {
+        provider,
+        modelIdentifier: provider ? `${provider}:${plainModel}` : plainModel,
+        providerCorrectionReason,
+    };
 }
 function normalizeLangChainProvider(provider) {
     switch (provider) {
@@ -113,8 +258,223 @@ function buildModelConfig(config) {
         configuration: config.baseURL ? { baseURL: config.baseURL } : undefined,
     });
 }
-function buildProviderEnv(config) {
-    const provider = normalizeLangChainProvider(config.provider);
+function inferLangChainProviderFromBaseURL(baseURL) {
+    if (!baseURL)
+        return undefined;
+    try {
+        const hostname = new URL(baseURL).hostname.toLowerCase();
+        if (hostname === 'open.bigmodel.cn' || hostname.endsWith('.bigmodel.cn'))
+            return 'openai';
+    }
+    catch {
+        return undefined;
+    }
+    return undefined;
+}
+function stripLangChainProviderPrefix(model) {
+    const match = /^(anthropic|openai|google-genai):(.+)$/i.exec(model);
+    return match?.[2] || model;
+}
+export function stringifyToolResult(result) {
+    if (result === undefined)
+        return 'null';
+    if (typeof result === 'string')
+        return result;
+    try {
+        return JSON.stringify(result, null, 2) ?? String(result);
+    }
+    catch {
+        return String(result);
+    }
+}
+function createLangChainMcpClient(mcpServers, output, options, log) {
+    log(`normalizing MCP servers | requested=${Object.keys(mcpServers ?? {}).join(',') || '-'}`);
+    const normalizedMcpServers = normalizeLangChainMcpServers(mcpServers);
+    if (!normalizedMcpServers) {
+        log('normalizing MCP servers | none');
+        return undefined;
+    }
+    log(`normalized MCP servers | ${summarizeMcpServersForLog(normalizedMcpServers)}`);
+    return new MultiServerMCPClient({
+        throwOnLoadError: true,
+        prefixToolNameWithServerName: true,
+        additionalToolNamePrefix: 'mcp',
+        useStandardContentBlocks: false,
+        outputHandling: 'content',
+        mcpServers: normalizedMcpServers,
+        beforeToolCall: (request) => {
+            const name = formatMcpToolName(request.serverName, request.name);
+            const line = `Tool: ${name} input=${JSON.stringify(request.args ?? {})}`;
+            log(`tool use | source=mcp server=${request.serverName} name=${name} input=${summarizeForLog(request.args ?? {}, 800)}`);
+            output.push(line);
+            options?.onEvent?.({ type: 'tool_use', id: name, name, input: request.args ?? {}, line });
+        },
+        afterToolCall: (result) => {
+            const name = formatMcpToolName(result.serverName, result.name);
+            const outputText = stringifyToolResult(result.result);
+            log(`tool result | source=mcp server=${result.serverName} name=${name} chars=${outputText.length} output=${truncateForLog(outputText, 1000)}`);
+            options?.onEvent?.({ type: 'tool_result', toolUseId: name, result: outputText });
+            return { result: outputText };
+        },
+        onProgress: (progress, source) => {
+            if (source.type !== 'tool')
+                return;
+            const name = formatMcpToolName(source.server, source.name);
+            const progressText = progress.total
+                ? `${progress.progress}/${progress.total}`
+                : String(progress.progress);
+            log(`tool progress | source=mcp server=${source.server} name=${name} progress=${progressText}${progress.message ? ` message=${truncateForLog(progress.message, 300)}` : ''}`);
+        },
+        onMessage: (message, source) => {
+            log(`mcp message | server=${source.server} level=${message.level ?? '-'} data=${summarizeForLog(message.data, 500)}`);
+        },
+    });
+}
+export function normalizeLangChainMcpServers(mcpServers) {
+    if (!mcpServers || Object.keys(mcpServers).length === 0)
+        return undefined;
+    return Object.fromEntries(Object.entries(mcpServers).map(([name, server]) => [name, normalizeLangChainMcpServer(server)]));
+}
+function normalizeLangChainMcpServer(server) {
+    if (!isRecord(server)) {
+        throw new Error('MCP server config must be an object.');
+    }
+    const normalized = normalizeOpenAgentCompatibleFetchMcpServer(server);
+    if (typeof normalized.url === 'string') {
+        return removeUndefined({
+            ...normalized,
+            transport: normalized.transport === 'sse' || normalized.type === 'sse' ? 'sse' : 'http',
+            url: normalized.url,
+            headers: isStringRecord(normalized.headers) ? normalized.headers : undefined,
+        });
+    }
+    if (typeof normalized.command === 'string') {
+        return removeUndefined({
+            ...normalized,
+            transport: 'stdio',
+            command: normalized.command,
+            args: Array.isArray(normalized.args) ? normalized.args.map(String) : [],
+            env: isStringRecord(normalized.env) ? normalized.env : undefined,
+            cwd: typeof normalized.cwd === 'string' ? normalized.cwd : undefined,
+        });
+    }
+    throw new Error('MCP server config requires either url or command.');
+}
+function normalizeOpenAgentCompatibleFetchMcpServer(server) {
+    const args = Array.isArray(server.args) ? server.args.map(String) : undefined;
+    const badFetchPackageIndex = args?.indexOf('@modelcontextprotocol/server-fetch') ?? -1;
+    if (String(server.command) !== 'npx' || !args || badFetchPackageIndex < 0)
+        return server;
+    return {
+        ...server,
+        command: 'uvx',
+        args: ['mcp-server-fetch', ...args.slice(badFetchPackageIndex + 1)],
+        env: {
+            PYTHONIOENCODING: 'utf-8',
+            ...(isStringRecord(server.env) ? server.env : {}),
+        },
+    };
+}
+function formatMcpToolName(serverName, toolName) {
+    return `mcp__${serverName}__${toolName}`;
+}
+function summarizeOptionsForLog(options) {
+    if (!options)
+        return '-';
+    return summarizeForLog({
+        maxTurns: options.maxTurns,
+        tools: options.tools,
+        functionTools: options.functionTools?.map((runtimeTool) => ({
+            name: runtimeTool.name,
+            descriptionChars: runtimeTool.description.length,
+            annotations: runtimeTool.annotations,
+            inputSchema: runtimeTool.inputSchema,
+        })),
+        mcpServers: Object.keys(options.mcpServers ?? {}),
+        skills: options.skills,
+        configDir: options.configDir,
+        sandboxDirs: options.sandboxDirs,
+        systemPromptChars: options.systemPrompt?.length,
+        userPromptChars: options.userPrompt?.length,
+        outputStyle: options.outputStyle,
+        resumeSessionId: options.resumeSessionId,
+        onEvent: options.onEvent ? 'set' : undefined,
+    }, 2000);
+}
+function summarizeAgentResultForLog(result) {
+    if (!isRecord(result))
+        return summarizeForLog(result, 1200);
+    const messages = Array.isArray(result.messages) ? result.messages : [];
+    return summarizeForLog({
+        keys: Object.keys(result),
+        messageCount: messages.length,
+        messages: messages.map((message, index) => summarizeMessageForLog(message, index)),
+    }, 2000);
+}
+function summarizeMessageForLog(message, index) {
+    if (!isRecord(message))
+        return { index, type: typeof message };
+    const content = stringifyMessageContent(message.content);
+    return removeUndefined({
+        index,
+        type: getMessageType(message) ?? message.type,
+        role: message.role,
+        name: message.name,
+        id: message.id,
+        contentChars: content.length,
+        contentPreview: truncateForLog(content, 300),
+        usage: message.usage_metadata,
+        responseMetadataKeys: isRecord(message.response_metadata) ? Object.keys(message.response_metadata) : undefined,
+        additionalKwargsKeys: isRecord(message.additional_kwargs) ? Object.keys(message.additional_kwargs) : undefined,
+        toolCallCount: Array.isArray(message.tool_calls) ? message.tool_calls.length : undefined,
+        invalidToolCallCount: Array.isArray(message.invalid_tool_calls) ? message.invalid_tool_calls.length : undefined,
+    });
+}
+function summarizeMcpServersForLog(mcpServers) {
+    return summarizeForLog(Object.fromEntries(Object.entries(mcpServers).map(([name, server]) => [name, summarizeMcpServerForLog(server)])), 2000);
+}
+function summarizeMcpServerForLog(server) {
+    const record = server;
+    return removeUndefined({
+        transport: record.transport,
+        url: typeof record.url === 'string' ? record.url : undefined,
+        command: typeof record.command === 'string' ? record.command : undefined,
+        args: Array.isArray(record.args) ? record.args : undefined,
+        cwd: typeof record.cwd === 'string' ? record.cwd : undefined,
+        headers: isStringRecord(record.headers) ? Object.keys(record.headers) : undefined,
+        env: isStringRecord(record.env) ? Object.keys(record.env) : undefined,
+    });
+}
+function summarizeEnvForLog(env) {
+    const configured = Object.entries(env)
+        .filter(([, value]) => Boolean(value))
+        .map(([key]) => key);
+    return configured.length ? configured.join(',') : '-';
+}
+function maskSensitiveConfig(config) {
+    return Object.fromEntries(Object.entries(config).map(([key, value]) => {
+        if (/api[_-]?key/i.test(key))
+            return [key, value ? 'set' : value];
+        if (key === 'configuration' && isRecord(value))
+            return [key, maskSensitiveConfig(value)];
+        return [key, value];
+    }));
+}
+function getObjectTypeName(value) {
+    return isRecord(value) && typeof value.constructor === 'function'
+        ? value.constructor.name
+        : typeof value;
+}
+function summarizeForLog(value, maxLength = 300) {
+    if (typeof value === 'string')
+        return truncateForLog(value, maxLength);
+    return truncateForLog(stringifyToolResult(value), maxLength);
+}
+function truncateForLog(value, maxLength = 300) {
+    return value.length > maxLength ? `${value.slice(0, maxLength)}...` : value;
+}
+function buildProviderEnv(config, resolvedProvider) {
+    const provider = resolvedProvider ?? normalizeLangChainProvider(config.provider);
     return {
         OPENAI_API_KEY: provider === 'openai' ? config.apiKey : undefined,
         OPENAI_BASE_URL: provider === 'openai' ? config.baseURL : undefined,
@@ -201,6 +561,9 @@ function numberFrom(value) {
 function isRecord(value) {
     return Boolean(value && typeof value === 'object');
 }
+function isStringRecord(value) {
+    return isRecord(value) && Object.values(value).every((entry) => typeof entry === 'string');
+}
 function removeUndefined(value) {
     return Object.fromEntries(Object.entries(value).filter(([, entry]) => entry !== undefined));
 }