living-ai-documentation 2.0.0 → 2.3.0

package/dist/src/routes/workspace.js

@@ -7,11 +7,14 @@ exports.workspaceRouter = workspaceRouter;
 const express_1 = require("express");
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
+const config_1 = require("../lib/config");
 const WORKSPACE_VERSION = 1;
 const MAX_WORKSPACE_ENTITIES = 1000;
 const MAX_LABEL_LENGTH = 160;
 const MAX_TEXT_FIELD_LENGTH = 4000;
 const MAX_WORKSPACE_FILE_BYTES = 1024 * 1024;
+const WORKSPACE_PROVIDER_ROOT = path_1.default.join('AI', 'WORKSPACE');
+const DEFAULT_LLM_TEST_TIMEOUT_MS = 5000;
 function workspaceFilePath(docsPath) {
     return path_1.default.join(docsPath, '.workspace');
 }
@@ -41,7 +44,7 @@ function writeWorkspaceState(docsPath, state) {
     fs_1.default.writeFileSync(tmpPath, JSON.stringify(state, null, 2), 'utf-8');
     fs_1.default.renameSync(tmpPath, filePath);
 }
-function sanitizeWorkspaceState(input) {
+function sanitizeWorkspaceState(input, docsPath) {
     if (!isRecord(input)) {
         throw new Error('workspace payload must be an object');
     }
@@ -55,12 +58,16 @@ function sanitizeWorkspaceState(input) {
     const updatedAt = typeof input.updatedAt === 'string' && input.updatedAt.trim()
         ? input.updatedAt
         : new Date().toISOString();
-    return {
+    const state = {
         version: WORKSPACE_VERSION,
         updatedAt,
         entities: entitiesInput.map(sanitizeEntity),
         camera: sanitizeCamera(input.camera),
     };
+    if (docsPath) {
+        ensureProviderWorkspaceFolders(docsPath, state);
+    }
+    return state;
 }
 function sanitizeEntity(input) {
     if (!isRecord(input)) {
@@ -85,14 +92,91 @@ function sanitizeEntity(input) {
 function sanitizeConfig(input) {
     const config = isRecord(input) ? input : {};
     return {
-        environment: safeOptionalString(config.environment, 'local', MAX_LABEL_LENGTH),
         endpoint: safeOptionalString(config.endpoint, '', MAX_TEXT_FIELD_LENGTH),
         token: safeOptionalString(config.token, '', MAX_TEXT_FIELD_LENGTH),
-        timeout: clamp(safeFiniteNumber(config.timeout, 30), 1, 120),
-        retryPolicy: safeOptionalString(config.retryPolicy, 'linear', MAX_LABEL_LENGTH),
+        model: safeOptionalString(config.model, '', MAX_LABEL_LENGTH),
+        timeout: clamp(safeFiniteNumber(config.timeout, 180), 1, 600),
+        systemPrompt: safeOptionalString(config.systemPrompt, '', MAX_TEXT_FIELD_LENGTH),
+        requiresUserInput: config.requiresUserInput === true,
+        userInputDescription: safeOptionalString(config.userInputDescription, '', MAX_TEXT_FIELD_LENGTH),
+        expectedOutputMarker: safeOptionalString(config.expectedOutputMarker, '', MAX_LABEL_LENGTH),
         description: safeOptionalString(config.description, '', MAX_TEXT_FIELD_LENGTH),
+        workspaceFolder: sanitizeWorkspaceFolder(safeOptionalString(config.workspaceFolder, '', MAX_TEXT_FIELD_LENGTH)),
     };
 }
+function ensureProviderWorkspaceFolders(docsPath, state) {
+    const workspaceRoot = path_1.default.resolve(docsPath, WORKSPACE_PROVIDER_ROOT);
+    fs_1.default.mkdirSync(workspaceRoot, { recursive: true });
+    const reservedFolders = new Set();
+    for (const entity of state.entities) {
+        if (entity.kind !== 'agent') {
+            entity.config.workspaceFolder = '';
+            continue;
+        }
+        const existingFolder = sanitizeWorkspaceFolder(entity.config.workspaceFolder);
+        const labelFolder = toPosixPath(path_1.default.join(WORKSPACE_PROVIDER_ROOT, slugify(entity.label)));
+        // Rename existing folder if label slug changed
+        if (existingFolder && existingFolder !== labelFolder) {
+            const absoluteExisting = path_1.default.resolve(docsPath, existingFolder);
+            if (fs_1.default.existsSync(absoluteExisting)) {
+                const uniqueLabel = uniqueWorkspaceFolder(labelFolder, reservedFolders);
+                const absoluteNew = path_1.default.resolve(docsPath, uniqueLabel);
+                if (!absoluteNew.startsWith(`${workspaceRoot}${path_1.default.sep}`)) {
+                    throw new Error('provider workspace folder escapes AI/WORKSPACE');
+                }
+                fs_1.default.renameSync(absoluteExisting, absoluteNew);
+                entity.config.workspaceFolder = toPosixPath(uniqueLabel);
+                reservedFolders.add(entity.config.workspaceFolder);
+                continue;
+            }
+        }
+        const baseFolder = existingFolder || labelFolder;
+        const uniqueFolder = uniqueWorkspaceFolder(baseFolder, reservedFolders);
+        const absoluteFolder = path_1.default.resolve(docsPath, uniqueFolder);
+        if (!absoluteFolder.startsWith(`${workspaceRoot}${path_1.default.sep}`) && absoluteFolder !== workspaceRoot) {
+            throw new Error('provider workspace folder escapes AI/WORKSPACE');
+        }
+        fs_1.default.mkdirSync(absoluteFolder, { recursive: true });
+        entity.config.workspaceFolder = toPosixPath(uniqueFolder);
+        reservedFolders.add(entity.config.workspaceFolder);
+    }
+}
+function sanitizeWorkspaceFolder(folder) {
+    if (!folder) {
+        return '';
+    }
+    const normalized = toPosixPath(path_1.default.normalize(folder));
+    const prefix = toPosixPath(WORKSPACE_PROVIDER_ROOT);
+    if (normalized.startsWith('../') ||
+        path_1.default.isAbsolute(normalized) ||
+        normalized === prefix ||
+        !normalized.startsWith(`${prefix}/`)) {
+        return '';
+    }
+    return normalized;
+}
+function uniqueWorkspaceFolder(folder, reservedFolders) {
+    const parsed = path_1.default.posix.parse(toPosixPath(folder));
+    let candidate = toPosixPath(folder);
+    let index = 2;
+    while (reservedFolders.has(candidate)) {
+        candidate = path_1.default.posix.join(parsed.dir, `${parsed.name}_${index}`);
+        index += 1;
+    }
+    return candidate;
+}
+function slugify(value) {
+    const slug = value
+        .normalize('NFKD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '_')
+        .replace(/^_+|_+$/g, '');
+    return slug || 'llm_provider';
+}
+function toPosixPath(value) {
+    return value.split(path_1.default.sep).join('/');
+}
 function sanitizeCamera(input) {
     const camera = isRecord(input) ? input : {};
     return {
@@ -125,6 +209,326 @@ function clamp(value, min, max) {
 function isRecord(input) {
     return typeof input === 'object' && input !== null && !Array.isArray(input);
 }
+function llmModelsUrl(endpoint) {
+    const url = new URL(endpoint);
+    const cleanPath = url.pathname.replace(/\/+$/, '');
+    if (cleanPath.endsWith('/models')) {
+        url.pathname = cleanPath;
+    }
+    else if (cleanPath.endsWith('/v1')) {
+        url.pathname = `${cleanPath}/models`;
+    }
+    else {
+        url.pathname = `${cleanPath}/v1/models`;
+    }
+    return url;
+}
+async function testLlmConnection(input) {
+    if (typeof input.endpoint !== 'string' || !input.endpoint.trim()) {
+        throw new Error('endpoint is required');
+    }
+    const model = typeof input.model === 'string' ? input.model.trim() : '';
+    const timeoutSeconds = clamp(safeFiniteNumber(input.timeout, 5), 1, 30);
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutSeconds * 1000 || DEFAULT_LLM_TEST_TIMEOUT_MS);
+    const headers = { Accept: 'application/json', 'Content-Type': 'application/json' };
+    if (typeof input.token === 'string' && input.token.trim()) {
+        headers.Authorization = `Bearer ${input.token.trim()}`;
+    }
+    if (model) {
+        const base = input.endpoint.trim();
+        const chatUrl = new URL(base.endsWith('/v1') ? `${base}/chat/completions` : `${base}/v1/chat/completions`);
+        try {
+            const response = await fetch(chatUrl, {
+                method: 'POST',
+                headers,
+                signal: controller.signal,
+                body: JSON.stringify({
+                    model,
+                    messages: [{ role: 'user', content: 'ping' }],
+                    max_tokens: 1,
+                }),
+            });
+            const text = await response.text();
+            let replyModel = null;
+            try {
+                const body = JSON.parse(text);
+                if (isRecord(body) && typeof body.model === 'string') {
+                    replyModel = body.model;
+                }
+            }
+            catch { /* ignore */ }
+            return {
+                ok: response.ok,
+                status: response.status,
+                url: chatUrl.toString(),
+                detail: response.ok
+                    ? `Model ${replyModel ?? model} responded`
+                    : `Chat completion failed (${response.status})`,
+            };
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    }
+    const url = llmModelsUrl(input.endpoint.trim());
+    try {
+        const response = await fetch(url, {
+            method: 'GET',
+            headers,
+            signal: controller.signal,
+        });
+        const text = await response.text();
+        let modelCount = null;
+        try {
+            const body = JSON.parse(text);
+            if (isRecord(body) && Array.isArray(body.data)) {
+                modelCount = body.data.length;
+            }
+        }
+        catch { /* ignore */ }
+        return {
+            ok: response.ok,
+            status: response.status,
+            url: url.toString(),
+            detail: response.ok
+                ? modelCount !== null
+                    ? `Connection OK (${modelCount} model${modelCount === 1 ? '' : 's'})`
+                    : `Connection OK (${response.status})`
+                : `Connection failed (${response.status})`,
+        };
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+async function callMcp(endpoint, method, params) {
+    const response = await fetch(endpoint, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json', Accept: 'application/json, text/event-stream' },
+        body: JSON.stringify({ jsonrpc: '2.0', id: 1, method, params }),
+    });
+    const text = await response.text();
+    // Handle SSE (data: ...) or plain JSON
+    for (const line of text.split('\n')) {
+        const trimmed = line.startsWith('data:') ? line.slice(5).trim() : line.trim();
+        if (!trimmed || trimmed === '[DONE]')
+            continue;
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (isRecord(parsed) && isRecord(parsed.result))
+                return parsed.result;
+            if (isRecord(parsed) && parsed.error)
+                throw new Error(String(parsed.error.message ?? parsed.error));
+        }
+        catch {
+            continue;
+        }
+    }
+    throw new Error('No valid MCP response');
+}
+async function runAgent(config) {
+    if (!config.endpoint.trim())
+        throw new Error('endpoint is required');
+    if (!config.model.trim())
+        throw new Error('model is required');
+    if (!config.systemPrompt.trim())
+        throw new Error('systemPrompt is required');
+    const timeoutSeconds = clamp(config.timeout, 1, 600);
+    const base = config.endpoint.trim();
+    const chatUrl = new URL(base.endsWith('/v1') ? `${base}/chat/completions` : `${base}/v1/chat/completions`);
+    const llmHeaders = { Accept: 'application/json', 'Content-Type': 'application/json' };
+    if (config.token.trim()) {
+        llmHeaders.Authorization = `Bearer ${config.token.trim()}`;
+    }
+    let mcpTools = [];
+    if (config.mcpEndpoint) {
+        try {
+            const toolsRes = await callMcp(config.mcpEndpoint, 'tools/list', {});
+            if (isRecord(toolsRes) && Array.isArray(toolsRes.tools)) {
+                mcpTools = toolsRes.tools.map((tool) => {
+                    if (!isRecord(tool))
+                        return null;
+                    return {
+                        type: 'function',
+                        function: {
+                            name: tool.name,
+                            description: tool.description ?? '',
+                            parameters: tool.inputSchema ?? { type: 'object', properties: {} },
+                        },
+                    };
+                }).filter(Boolean);
+            }
+        }
+        catch {
+            mcpTools = [];
+        }
+    }
+    const messages = [{ role: 'system', content: config.systemPrompt.trim() }];
+    const expectedOutputMarker = config.expectedOutputMarker.trim();
+    if (config.userInput.trim()) {
+        messages.push({ role: 'user', content: config.userInput.trim() });
+    }
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutSeconds * 1000);
+    let toolsSupported = mcpTools.length > 0;
+    try {
+        for (let turn = 0; turn < 5; turn += 1) {
+            const llmBody = { model: config.model.trim(), messages };
+            if (toolsSupported && mcpTools.length > 0)
+                llmBody.tools = mcpTools;
+            const response = await fetch(chatUrl, {
+                method: 'POST',
+                headers: llmHeaders,
+                signal: controller.signal,
+                body: JSON.stringify(llmBody),
+            });
+            // Model doesn't support tool use — retry once without tools
+            if (!response.ok && response.status === 400 && toolsSupported) {
+                toolsSupported = false;
+                // Inject tool descriptions as context in the system message
+                const toolDescriptions = mcpTools
+                    .map((t) => {
+                    if (!isRecord(t) || !isRecord(t.function))
+                        return '';
+                    return `- ${t.function.name}: ${t.function.description ?? ''}`;
+                })
+                    .filter(Boolean)
+                    .join('\n');
+                if (toolDescriptions && messages.length > 0 && isRecord(messages[0]) && messages[0].role === 'system') {
+                    messages[0].content =
+                        `${messages[0].content}\n\nAvailable MCP tools (call them by name in your response):\n${toolDescriptions}`;
+                }
+                continue;
+            }
+            if (!response.ok) {
+                throw new Error(`LLM error (${response.status})`);
+            }
+            const parsed = JSON.parse(await response.text());
+            if (!isRecord(parsed) || !Array.isArray(parsed.choices) || !parsed.choices.length)
+                break;
+            const choice = parsed.choices[0];
+            if (!isRecord(choice) || !isRecord(choice.message))
+                break;
+            const msg = choice.message;
+            messages.push(msg);
+            if (Array.isArray(msg.tool_calls) && msg.tool_calls.length > 0 && config.mcpEndpoint) {
+                for (const toolCall of msg.tool_calls) {
+                    if (!isRecord(toolCall) || !isRecord(toolCall.function))
+                        continue;
+                    const fnName = typeof toolCall.function.name === 'string' ? toolCall.function.name : '';
+                    const fnArgs = typeof toolCall.function.arguments === 'string'
+                        ? JSON.parse(toolCall.function.arguments)
+                        : (toolCall.function.arguments ?? {});
+                    let toolResult = '';
+                    try {
+                        const mcpResult = await callMcp(config.mcpEndpoint, 'tools/call', { name: fnName, arguments: fnArgs });
+                        if (isRecord(mcpResult) && Array.isArray(mcpResult.content)) {
+                            toolResult = mcpResult.content
+                                .filter((content) => isRecord(content) && typeof content.text === 'string')
+                                .map((content) => content.text)
+                                .join('\n');
+                        }
+                        else {
+                            toolResult = JSON.stringify(mcpResult);
+                        }
+                    }
+                    catch (error) {
+                        toolResult = `Tool error: ${error instanceof Error ? error.message : String(error)}`;
+                    }
+                    messages.push({ role: 'tool', tool_call_id: toolCall.id ?? '', content: toolResult });
+                }
+                continue;
+            }
+            if (typeof msg.content === 'string' && msg.content.trim()) {
+                const content = msg.content.trim();
+                if (!expectedOutputMarker || content.includes(expectedOutputMarker)) {
+                    return content;
+                }
+                messages.push({
+                    role: 'user',
+                    content: `Your previous answer did not include the required output marker "${expectedOutputMarker}". ` +
+                        `Return the final answer now, include "${expectedOutputMarker}", and do not explain the correction.`,
+                });
+                continue;
+            }
+            break;
+        }
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    throw new Error(expectedOutputMarker
+        ? `Agent response did not include required output marker: ${expectedOutputMarker}`
+        : 'Agent did not produce a response');
+}
+function agentRunMarkdown(args) {
+    const status = args.ok ? 'Success' : 'Failed';
+    const userInput = args.userInput.trim() || '_No user input._';
+    return `---\n**date:** ${new Date().toISOString()}\n**status:** ${status}\n**description:** Resultat d'execution de l'agent ${args.agent.label} via ${args.provider.label}.\n**tags:** agent, run-agent, workspace, llm, ${slugify(args.agent.label)}\n---\n\n# ${args.title}\n\n## Execution\n\n- Agent: ${args.agent.label}\n- Provider: ${args.provider.label}\n- Model: ${args.provider.config.model}\n- Status: ${status}\n\n## User input\n\n${userInput}\n\n## Response\n\n${args.content}\n`;
+}
+function createAgentRunDocument(docsPath, agent, provider, ok, userInput, content) {
+    const folder = sanitizeWorkspaceFolder(agent.config.workspaceFolder);
+    if (!folder)
+        throw new Error('agent workspace folder is missing');
+    const docsRoot = path_1.default.resolve(docsPath);
+    const targetDir = path_1.default.resolve(docsPath, folder);
+    if (!targetDir.startsWith(`${docsRoot}${path_1.default.sep}`) && targetDir !== docsRoot) {
+        throw new Error('agent workspace folder escapes docs folder');
+    }
+    fs_1.default.mkdirSync(targetDir, { recursive: true });
+    const title = `Run - ${agent.label}`;
+    const baseFilename = buildWorkspaceFilenameForDocs(docsPath, title, 'AGENT');
+    const baseName = baseFilename.replace(/\.md$/, '');
+    let filename = baseFilename;
+    let filePath = path_1.default.join(targetDir, filename);
+    let suffix = 2;
+    while (fs_1.default.existsSync(filePath)) {
+        filename = `${baseName}_${suffix}.md`;
+        filePath = path_1.default.join(targetDir, filename);
+        suffix += 1;
+    }
+    fs_1.default.writeFileSync(filePath, agentRunMarkdown({ title, agent, provider, ok, userInput, content }), 'utf-8');
+    const relativePath = path_1.default.relative(docsPath, filePath);
+    return {
+        id: encodeURIComponent(relativePath.slice(0, -3)),
+        filename: relativePath,
+        title,
+        ok,
+    };
+}
+function findWorkspaceAgentRunContext(state, agentId) {
+    const agent = state.entities.find((entity) => entity.id === agentId && entity.kind === 'agent');
+    if (!agent) {
+        throw new Error('agent not found');
+    }
+    const provider = state.entities.find((entity) => entity.id === agent.parentId && entity.kind === 'llm');
+    if (!provider) {
+        throw new Error('agent parent LLM provider not found');
+    }
+    return {
+        agent,
+        provider,
+        mcp: state.entities.find((entity) => entity.kind === 'mcp') ?? null,
+    };
+}
+function buildWorkspaceFilenameForDocs(docsPath, title, category) {
+    const { filenamePattern } = (0, config_1.readConfig)(docsPath);
+    const now = new Date();
+    const yyyy = String(now.getFullYear());
+    const mm = String(now.getMonth() + 1).padStart(2, '0');
+    const dd = String(now.getDate()).padStart(2, '0');
+    const hh = String(now.getHours()).padStart(2, '0');
+    const min = String(now.getMinutes()).padStart(2, '0');
+    return (filenamePattern || 'YYYY_MM_DD_HH_mm_[Category]_title')
+        .replace('YYYY', yyyy)
+        .replace('MM', mm)
+        .replace('DD', dd)
+        .replace('HH', hh)
+        .replace('mm', min)
+        .replace(/\[Category\]/i, `[${category}]`)
+        .replace(/(?<![a-z0-9])(?:title_words|title)(?![a-z0-9])/i, slugify(title)) + '.md';
+}
 function workspaceRouter(docsPath) {
     const router = (0, express_1.Router)();
     router.get('/', (_req, res) => {
@@ -140,7 +544,7 @@ function workspaceRouter(docsPath) {
             const state = sanitizeWorkspaceState({
                 ...req.body,
                 updatedAt: new Date().toISOString(),
-            });
+            }, docsPath);
             writeWorkspaceState(docsPath, state);
             res.json(state);
         }
@@ -149,6 +553,124 @@ function workspaceRouter(docsPath) {
             res.status(400).json({ error: message });
         }
     });
+    router.post('/list-models', async (req, res) => {
+        try {
+            const body = req.body;
+            if (typeof body.endpoint !== 'string' || !body.endpoint.trim()) {
+                res.status(400).json({ ok: false, error: 'endpoint is required' });
+                return;
+            }
+            const url = llmModelsUrl(body.endpoint.trim());
+            const headers = { Accept: 'application/json' };
+            if (typeof body.token === 'string' && body.token.trim()) {
+                headers.Authorization = `Bearer ${body.token.trim()}`;
+            }
+            const controller = new AbortController();
+            const timeout = setTimeout(() => controller.abort(), DEFAULT_LLM_TEST_TIMEOUT_MS);
+            try {
+                const response = await fetch(url, { method: 'GET', headers, signal: controller.signal });
+                const text = await response.text();
+                let models = [];
+                try {
+                    const parsed = JSON.parse(text);
+                    if (isRecord(parsed) && Array.isArray(parsed.data)) {
+                        models = parsed.data
+                            .map((m) => (isRecord(m) && typeof m.id === 'string' ? m.id : null))
+                            .filter((id) => id !== null);
+                    }
+                }
+                catch { /* ignore */ }
+                res.json({ ok: response.ok, models });
+            }
+            finally {
+                clearTimeout(timeout);
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to list models';
+            res.status(400).json({ ok: false, error: message });
+        }
+    });
+    router.post('/run-agent-document', async (req, res) => {
+        try {
+            const body = req.body;
+            if (typeof body.agentId !== 'string' || !body.agentId.trim()) {
+                res.status(400).json({ ok: false, error: 'agentId is required' });
+                return;
+            }
+            const state = readWorkspaceState(docsPath);
+            ensureProviderWorkspaceFolders(docsPath, state);
+            writeWorkspaceState(docsPath, state);
+            const { agent, provider, mcp } = findWorkspaceAgentRunContext(state, body.agentId.trim());
+            const userInput = typeof body.userInput === 'string' ? body.userInput.trim() : '';
+            try {
+                const content = await runAgent({
+                    endpoint: provider.config.endpoint,
+                    token: provider.config.token,
+                    model: agent.config.model || provider.config.model,
+                    systemPrompt: agent.config.systemPrompt,
+                    userInput,
+                    timeout: agent.config.timeout || provider.config.timeout,
+                    mcpEndpoint: mcp?.config.endpoint ?? '',
+                    expectedOutputMarker: agent.config.expectedOutputMarker,
+                });
+                const document = createAgentRunDocument(docsPath, agent, provider, true, userInput, content);
+                res.json({ ok: true, content, document });
+            }
+            catch (error) {
+                const message = error instanceof Error ? error.message : 'Agent run failed';
+                const document = createAgentRunDocument(docsPath, agent, provider, false, userInput, message);
+                res.status(502).json({ ok: false, error: message, document });
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Agent run failed';
+            const status = message === 'agent not found' ? 404 : 400;
+            res.status(status).json({ ok: false, error: message });
+        }
+    });
+    router.post('/run-agent', async (req, res) => {
+        try {
+            const body = req.body;
+            if (typeof body.endpoint !== 'string' || !body.endpoint.trim()) {
+                res.status(400).json({ ok: false, error: 'endpoint is required' });
+                return;
+            }
+            if (typeof body.model !== 'string' || !body.model.trim()) {
+                res.status(400).json({ ok: false, error: 'model is required' });
+                return;
+            }
+            if (typeof body.systemPrompt !== 'string' || !body.systemPrompt.trim()) {
+                res.status(400).json({ ok: false, error: 'systemPrompt is required' });
+                return;
+            }
+            const content = await runAgent({
+                endpoint: body.endpoint,
+                token: typeof body.token === 'string' ? body.token : '',
+                model: body.model,
+                systemPrompt: body.systemPrompt,
+                userInput: typeof body.userInput === 'string' ? body.userInput : '',
+                timeout: clamp(safeFiniteNumber(body.timeout, 180), 1, 600),
+                mcpEndpoint: typeof body.mcpEndpoint === 'string' ? body.mcpEndpoint : '',
+                expectedOutputMarker: typeof body.expectedOutputMarker === 'string' ? body.expectedOutputMarker : '',
+            });
+            res.json({ ok: true, content });
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Agent run failed';
+            res.status(400).json({ ok: false, error: message });
+        }
+    });
+    router.post('/test-llm', async (req, res) => {
+        try {
+            const result = await testLlmConnection(req.body);
+            res.status(result.ok ? 200 : 502).json(result);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Failed to test LLM connection';
+            res.status(400).json({ ok: false, error: message });
+        }
+    });
     return router;
 }
 //# sourceMappingURL=workspace.js.map