@mcp-abap-adt/llm-agent 8.5.0 → 10.0.0

package/dist/smart-agent/smart-server.js

@@ -1,903 +0,0 @@
-/**
- * SmartServer — embeddable OpenAI-compatible HTTP server backed by SmartAgent.
- */
-import { randomUUID } from 'node:crypto';
-import http from 'node:http';
-import { PACKAGE_VERSION } from '../generated/version.js';
-import { SmartAgentBuilder } from './builder.js';
-import { ConfigWatcher, } from './config/config-watcher.js';
-import { HealthChecker } from './health/health-checker.js';
-import { AdapterValidationError } from './interfaces/api-adapter.js';
-import { SessionLogger } from './logger/session-logger.js';
-import { FileSystemPluginLoader, getDefaultPluginDirs, } from './plugins/index.js';
-import { makeDefaultLlm, makeLlm, makeRag } from './providers.js';
-import { ClaudeSkillManager } from './skills/claude-skill-manager.js';
-import { CodexSkillManager } from './skills/codex-skill-manager.js';
-import { FileSystemSkillManager } from './skills/filesystem-skill-manager.js';
-import { normalizeAndValidateExternalTools, } from './utils/external-tools-normalizer.js';
-import { toToolCallDelta } from './utils/tool-call-deltas.js';
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function mapStopReason(r) {
-    if (r === 'stop')
-        return 'stop';
-    if (r === 'tool_calls')
-        return 'tool_calls';
-    return 'length';
-}
-function jsonError(message, type, code) {
-    return JSON.stringify({
-        error: { message, type, ...(code ? { code } : {}) },
-    });
-}
-function jsonValidationError(message, code, param) {
-    return JSON.stringify({
-        error: {
-            message,
-            type: 'invalid_request_error',
-            code,
-            param,
-        },
-    });
-}
-function readBody(req) {
-    return new Promise((resolve, reject) => {
-        const chunks = [];
-        req.on('data', (c) => chunks.push(c));
-        req.on('end', () => resolve(Buffer.concat(chunks).toString('utf8')));
-        req.on('error', reject);
-    });
-}
-function resolveSkillManager(cfg) {
-    if (!cfg)
-        return undefined;
-    const type = cfg.type ?? 'claude';
-    const root = cfg.projectRoot ?? process.cwd();
-    switch (type) {
-        case 'claude':
-            return new ClaudeSkillManager(root);
-        case 'codex':
-            return new CodexSkillManager(root);
-        case 'filesystem':
-            return new FileSystemSkillManager(cfg.dirs ?? []);
-        default:
-            return undefined;
-    }
-}
-const CORS_HEADERS = {
-    'Access-Control-Allow-Origin': '*',
-    'Access-Control-Allow-Methods': 'GET, POST, PUT, OPTIONS',
-    'Access-Control-Allow-Headers': 'Content-Type, Authorization',
-};
-// ---------------------------------------------------------------------------
-// SmartServer
-// ---------------------------------------------------------------------------
-export { generateConfigTemplate, loadYamlConfig, resolveEnvVars, resolveSmartServerConfig, YAML_TEMPLATE, } from './config.js';
-export class SmartServer {
-    cfg;
-    noop = () => { };
-    constructor(config) {
-        this.cfg = config;
-    }
-    async start() {
-        const log = this.cfg.log ?? this.noop;
-        const fileLogger = {
-            log: (e) => log(e),
-        };
-        const pipeline = this.cfg.pipeline;
-        // ---- Composition root: resolve config → interfaces --------------------
-        // LLM resolution
-        const mainTemp = Number(pipeline?.llm?.main?.temperature ?? this.cfg.llm.temperature ?? 0.7);
-        const mainLlm = pipeline?.llm?.main
-            ? makeLlm(pipeline.llm.main, mainTemp)
-            : makeDefaultLlm(this.cfg.llm.apiKey, this.cfg.llm.model ?? 'deepseek-chat', mainTemp);
-        const classifierTemp = Number(pipeline?.llm?.classifier?.temperature ??
-            this.cfg.llm.classifierTemperature ??
-            0.1);
-        const classifierLlm = pipeline?.llm?.classifier
-            ? makeLlm(pipeline.llm.classifier, classifierTemp)
-            : pipeline?.llm?.main
-                ? makeLlm(pipeline.llm.main, classifierTemp)
-                : makeDefaultLlm(this.cfg.llm.apiKey, this.cfg.llm.model ?? 'deepseek-chat', classifierTemp);
-        const helperLlm = pipeline?.llm?.helper
-            ? makeLlm(pipeline.llm.helper, Number(pipeline.llm.helper.temperature ?? 0.1))
-            : undefined;
-        // ---- Plugin loader -------------------------------------------------------
-        const pluginLoader = this.cfg.pluginLoader ??
-            (() => {
-                const dirs = getDefaultPluginDirs();
-                if (this.cfg.pluginDir)
-                    dirs.push(this.cfg.pluginDir);
-                return new FileSystemPluginLoader({
-                    dirs,
-                    log: (msg) => log({ event: 'plugin_loader', message: msg }),
-                });
-            })();
-        // Pre-load to extract embedder factories (needed before RAG resolution)
-        const plugins = await pluginLoader.load();
-        if (plugins.loadedFiles.length > 0) {
-            log({
-                event: 'plugins_loaded',
-                files: plugins.loadedFiles,
-                stageHandlers: [...plugins.stageHandlers.keys()],
-                embedderFactories: Object.keys(plugins.embedderFactories),
-                hasReranker: !!plugins.reranker,
-                hasQueryExpander: !!plugins.queryExpander,
-                hasOutputValidator: !!plugins.outputValidator,
-                mcpClients: plugins.mcpClients.length,
-            });
-        }
-        if (plugins.errors.length > 0) {
-            log({ event: 'plugin_errors', errors: plugins.errors });
-        }
-        // Merge plugin embedder factories with config-provided ones
-        const mergedEmbedderFactories = {
-            ...plugins.embedderFactories,
-            ...this.cfg.embedderFactories, // config takes precedence over plugins
-        };
-        // ---- Build agent via Builder (interface-only) -------------------------
-        let builder = new SmartAgentBuilder({
-            mcp: pipeline?.mcp ?? this.cfg.mcp,
-            agent: this.cfg.agent,
-            prompts: this.cfg.prompts,
-            skipModelValidation: this.cfg.skipModelValidation,
-        })
-            .withMainLlm(mainLlm)
-            .withClassifierLlm(classifierLlm)
-            .withLogger(fileLogger)
-            .withMode(this.cfg.mode ?? 'smart');
-        if (helperLlm) {
-            builder = builder.withHelperLlm(helperLlm);
-        }
-        if (this.cfg.rag) {
-            const ragOptions = {
-                injectedEmbedder: this.cfg.embedder,
-                extraFactories: mergedEmbedderFactories,
-            };
-            builder = builder.setToolsRag(makeRag(this.cfg.rag, ragOptions));
-            builder = builder.setHistoryRag(makeRag({ ...this.cfg.rag }, ragOptions));
-        }
-        if (this.cfg.circuitBreaker) {
-            builder = builder.withCircuitBreaker(this.cfg.circuitBreaker);
-        }
-        if (plugins.reranker) {
-            builder = builder.withReranker(plugins.reranker);
-        }
-        if (plugins.queryExpander) {
-            builder = builder.withQueryExpander(plugins.queryExpander);
-        }
-        if (plugins.outputValidator) {
-            builder = builder.withOutputValidator(plugins.outputValidator);
-        }
-        // Skill manager (DI > YAML config > plugin)
-        const skillManager = this.cfg.skillManager ??
-            plugins.skillManager ??
-            resolveSkillManager(this.cfg.skills);
-        if (skillManager) {
-            builder = builder.withSkillManager(skillManager);
-        }
-        // LLM call strategy (from agent config)
-        const strategyName = this.cfg.agent?.llmCallStrategy;
-        if (strategyName) {
-            const { StreamingLlmCallStrategy } = await import('./policy/streaming-llm-call-strategy.js');
-            const { NonStreamingLlmCallStrategy } = await import('./policy/non-streaming-llm-call-strategy.js');
-            const { FallbackLlmCallStrategy } = await import('./policy/fallback-llm-call-strategy.js');
-            const strategies = {
-                streaming: () => new StreamingLlmCallStrategy(),
-                'non-streaming': () => new NonStreamingLlmCallStrategy(),
-                fallback: () => new FallbackLlmCallStrategy(fileLogger),
-            };
-            const factory = strategies[strategyName];
-            if (factory) {
-                builder = builder.withLlmCallStrategy(factory());
-            }
-        }
-        // MCP clients (DI > plugin; YAML fallback handled by builder)
-        const mcpClients = this.cfg.mcpClients ??
-            (plugins.mcpClients.length > 0 ? plugins.mcpClients : undefined);
-        if (mcpClients) {
-            builder = builder.withMcpClients(mcpClients);
-        }
-        // Client adapters (DI > plugin; ClineClientAdapter is always registered as default)
-        const { ClineClientAdapter } = await import('./adapters/cline-client-adapter.js');
-        const adapterSources = [
-            ...(this.cfg.clientAdapters ?? []),
-            ...plugins.clientAdapters,
-            new ClineClientAdapter(),
-        ];
-        for (const adapter of adapterSources) {
-            builder = builder.withClientAdapter(adapter);
-        }
-        const agentHandle = await builder.build();
-        const { agent: smartAgent, chat, streamChat, close: closeAgent, circuitBreakers, ragStores, modelProvider, } = agentHandle;
-        // ---- API adapter map (built-in → config DI; DI wins) --------------------
-        const { OpenAiApiAdapter } = await import('./api-adapters/openai-adapter.js');
-        const { AnthropicApiAdapter } = await import('./api-adapters/anthropic-adapter.js');
-        const adapterMap = new Map();
-        if (!this.cfg.disableBuiltInAdapters) {
-            const openai = new OpenAiApiAdapter();
-            const anthropic = new AnthropicApiAdapter();
-            adapterMap.set(openai.name, openai);
-            adapterMap.set(anthropic.name, anthropic);
-        }
-        if (this.cfg.apiAdapters) {
-            for (const adapter of this.cfg.apiAdapters) {
-                adapterMap.set(adapter.name, adapter);
-            }
-        }
-        const closeFns = [closeAgent];
-        const startTime = Date.now();
-        const healthChecker = new HealthChecker({
-            agent: smartAgent,
-            startTime,
-            version: this.cfg.version ?? PACKAGE_VERSION,
-            circuitBreakers,
-        });
-        // Startup health check removed — use llm-agent-check CLI for diagnostics.
-        // Running health check at startup wastes rate-limit budget when combined
-        // with tool vectorization (146+ embedding calls).
-        // ---- Config hot-reload (optional) ------------------------------------
-        if (this.cfg.configFile) {
-            const watcher = new ConfigWatcher(this.cfg.configFile);
-            watcher.on('reload', (update) => {
-                log({ event: 'config_reload', update });
-                // Apply agent config updates
-                const agentUpdate = {};
-                if (update.maxIterations !== undefined)
-                    agentUpdate.maxIterations = update.maxIterations;
-                if (update.maxToolCalls !== undefined)
-                    agentUpdate.maxToolCalls = update.maxToolCalls;
-                if (update.ragQueryK !== undefined)
-                    agentUpdate.ragQueryK = update.ragQueryK;
-                if (update.toolUnavailableTtlMs !== undefined)
-                    agentUpdate.toolUnavailableTtlMs = update.toolUnavailableTtlMs;
-                if (update.showReasoning !== undefined)
-                    agentUpdate.showReasoning = update.showReasoning;
-                if (update.historyAutoSummarizeLimit !== undefined)
-                    agentUpdate.historyAutoSummarizeLimit =
-                        update.historyAutoSummarizeLimit;
-                if (update.prompts?.ragTranslate !== undefined)
-                    agentUpdate.ragTranslatePrompt = update.prompts.ragTranslate;
-                if (update.prompts?.historySummary !== undefined)
-                    agentUpdate.historySummaryPrompt = update.prompts.historySummary;
-                if (update.classificationEnabled !== undefined)
-                    agentUpdate.classificationEnabled = update.classificationEnabled;
-                if (Object.keys(agentUpdate).length > 0) {
-                    smartAgent.applyConfigUpdate(agentUpdate);
-                }
-                // Apply RAG weight updates
-                if (update.vectorWeight !== undefined ||
-                    update.keywordWeight !== undefined) {
-                    for (const store of Object.values(ragStores)) {
-                        if (store &&
-                            typeof store.updateWeights === 'function') {
-                            store.updateWeights({
-                                vectorWeight: update.vectorWeight,
-                                keywordWeight: update.keywordWeight,
-                            });
-                        }
-                    }
-                }
-            });
-            watcher.on('error', (err) => {
-                log({ event: 'config_reload_error', error: String(err) });
-            });
-            watcher.start();
-            closeFns.push(() => watcher.stop());
-        }
-        const { requestLogger } = agentHandle;
-        const server = http.createServer((req, res) => this._handle(req, res, requestLogger, smartAgent, chat, streamChat, log, healthChecker, modelProvider, adapterMap).catch((err) => {
-            if (!res.headersSent) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(jsonError(String(err), 'server_error'));
-            }
-        }));
-        return new Promise((resolve, reject) => {
-            const port = this.cfg.port ?? 4004;
-            const host = this.cfg.host ?? '0.0.0.0';
-            server.on('error', reject);
-            server.listen(port, host, () => {
-                const addr = server.address();
-                const actualPort = typeof addr === 'object' && addr !== null ? addr.port : port;
-                log({ event: 'server_started', port: actualPort, host });
-                resolve({
-                    port: actualPort,
-                    close: async () => {
-                        for (const fn of closeFns)
-                            await fn();
-                        await new Promise((res, rej) => server.close((e) => (e ? rej(e) : res())));
-                    },
-                    requestLogger,
-                });
-            });
-        });
-    }
-    async _handle(req, res, requestLogger, smartAgent, chat, streamChat, log, healthChecker, modelProvider, adapterMap) {
-        const rawUrl = req.url ?? '/';
-        const urlPath = rawUrl.split('?')[0].replace(/\/$/, '') || '/';
-        for (const [k, v] of Object.entries(CORS_HEADERS))
-            res.setHeader(k, v);
-        if (req.method === 'OPTIONS') {
-            res.writeHead(204);
-            res.end();
-            return;
-        }
-        log({
-            event: 'http_request',
-            method: req.method,
-            url: rawUrl,
-            normalizedPath: urlPath,
-        });
-        if (req.method === 'GET' &&
-            (urlPath === '/v1/models' || urlPath === '/models')) {
-            const queryString = rawUrl.includes('?') ? rawUrl.split('?')[1] : '';
-            const queryParams = new URLSearchParams(queryString);
-            const excludeEmbedding = queryParams.get('exclude_embedding') === 'true';
-            let data = [
-                { id: 'smart-agent', object: 'model', owned_by: 'smart-agent' },
-            ];
-            if (modelProvider) {
-                const result = await modelProvider.getModels({ excludeEmbedding });
-                if (result.ok) {
-                    data = result.value.map((m) => ({
-                        id: m.id,
-                        object: 'model',
-                        owned_by: m.owned_by ?? 'unknown',
-                        ...(m.displayName ? { display_name: m.displayName } : {}),
-                        ...(m.provider ? { provider: m.provider } : {}),
-                        ...(m.capabilities ? { capabilities: m.capabilities } : {}),
-                        ...(m.contextLength ? { context_length: m.contextLength } : {}),
-                        ...(m.streamingSupported !== undefined
-                            ? { streaming_supported: m.streamingSupported }
-                            : {}),
-                        ...(m.deprecated !== undefined ? { deprecated: m.deprecated } : {}),
-                    }));
-                }
-            }
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ object: 'list', data }));
-            return;
-        }
-        if (req.method === 'GET' &&
-            (urlPath === '/v1/embedding-models' || urlPath === '/embedding-models')) {
-            let data = [];
-            if (modelProvider?.getEmbeddingModels) {
-                const result = await modelProvider.getEmbeddingModels();
-                if (result.ok) {
-                    data = result.value.map((m) => ({
-                        id: m.id,
-                        object: 'model',
-                        owned_by: m.owned_by ?? 'unknown',
-                        ...(m.displayName ? { display_name: m.displayName } : {}),
-                        ...(m.provider ? { provider: m.provider } : {}),
-                        ...(m.capabilities ? { capabilities: m.capabilities } : {}),
-                        ...(m.contextLength ? { context_length: m.contextLength } : {}),
-                        ...(m.streamingSupported !== undefined
-                            ? { streaming_supported: m.streamingSupported }
-                            : {}),
-                        ...(m.deprecated !== undefined ? { deprecated: m.deprecated } : {}),
-                    }));
-                }
-            }
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify({ object: 'list', data }));
-            return;
-        }
-        if (req.method === 'GET' && urlPath === '/v1/usage') {
-            res.writeHead(200, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(requestLogger.getSummary()));
-            return;
-        }
-        // /v1/config or /config
-        if (urlPath === '/v1/config' || urlPath === '/config') {
-            if (req.method === 'GET') {
-                const models = smartAgent.getActiveConfig();
-                const agent = smartAgent.getAgentConfig();
-                const body = { models, agent };
-                res.writeHead(200, { 'Content-Type': 'application/json' });
-                res.end(JSON.stringify(body));
-                return;
-            }
-            if (req.method === 'PUT') {
-                await this._handleConfigUpdate(req, res, smartAgent);
-                return;
-            }
-            // 405 for other methods
-            res.setHeader('Allow', 'GET, PUT, OPTIONS');
-            res.writeHead(405, { 'Content-Type': 'application/json' });
-            res.end(jsonError(`Method ${req.method} not allowed on ${urlPath}`, 'invalid_request_error'));
-            return;
-        }
-        if (req.method === 'GET' &&
-            (urlPath === '/health' || urlPath === '/v1/health')) {
-            const status = await healthChecker.check();
-            const httpCode = status.status === 'unhealthy' ? 503 : 200;
-            res.writeHead(httpCode, { 'Content-Type': 'application/json' });
-            res.end(JSON.stringify(status));
-            return;
-        }
-        // POST /v1/messages or /messages → Anthropic adapter
-        if (req.method === 'POST' &&
-            (urlPath === '/v1/messages' || urlPath === '/messages')) {
-            const anthropicAdapter = adapterMap?.get('anthropic');
-            if (!anthropicAdapter) {
-                res.writeHead(404, { 'Content-Type': 'application/json' });
-                res.end(jsonError('Anthropic adapter not registered', 'not_found'));
-                return;
-            }
-            await this._handleAdapterRequest(req, res, smartAgent, anthropicAdapter);
-            return;
-        }
-        if (req.method === 'POST' &&
-            (urlPath === '/v1/chat/completions' || urlPath === '/chat/completions')) {
-            await this._handleChat(req, res, requestLogger, smartAgent, chat, streamChat, log, modelProvider);
-            return;
-        }
-        res.writeHead(404, { 'Content-Type': 'application/json' });
-        res.end(jsonError(`Cannot ${req.method} ${urlPath}`, 'invalid_request_error'));
-    }
-    async _handleAdapterRequest(req, res, agent, adapter) {
-        const raw = await readBody(req);
-        let body;
-        try {
-            body = JSON.parse(raw);
-        }
-        catch {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(jsonError('Invalid JSON', 'invalid_request_error'));
-            return;
-        }
-        let normalized;
-        try {
-            normalized = adapter.normalizeRequest(body);
-        }
-        catch (err) {
-            if (err instanceof AdapterValidationError) {
-                res.writeHead(err.statusCode, { 'Content-Type': 'application/json' });
-                res.end(jsonError(err.message, 'invalid_request_error'));
-                return;
-            }
-            throw err;
-        }
-        if (normalized.stream) {
-            res.writeHead(200, {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                Connection: 'keep-alive',
-            });
-            for await (const event of adapter.transformStream(agent.streamProcess(normalized.messages, normalized.options), normalized.context)) {
-                const eventLine = event.event ? `event: ${event.event}\n` : '';
-                res.write(`${eventLine}data: ${event.data}\n\n`);
-            }
-            res.end();
-            return;
-        }
-        // Non-streaming
-        const result = await agent.process(normalized.messages, normalized.options);
-        res.setHeader('Content-Type', 'application/json');
-        if (!result.ok) {
-            res.writeHead(500);
-            res.end(JSON.stringify(adapter.formatError?.(result.error, normalized.context) ?? {
-                error: {
-                    message: result.error.message,
-                    type: result.error.code,
-                },
-            }));
-            return;
-        }
-        res.writeHead(200);
-        res.end(JSON.stringify(adapter.formatResult(result.value, normalized.context)));
-    }
-    async _handleChat(req, res, _requestLogger, smartAgent, _chat, _streamChat, log, modelProvider) {
-        const rawBody = await readBody(req);
-        let parsed;
-        try {
-            parsed = JSON.parse(rawBody);
-        }
-        catch {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(jsonError('Invalid JSON body', 'invalid_request_error'));
-            return;
-        }
-        if (typeof parsed !== 'object' ||
-            parsed === null ||
-            !Array.isArray(parsed.messages)) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(jsonError('messages must be a non-empty array', 'invalid_request_error'));
-            return;
-        }
-        const body = parsed;
-        const extractText = (c) => {
-            if (c === null || c === undefined)
-                return '';
-            if (typeof c === 'string')
-                return c;
-            if (!Array.isArray(c))
-                return '';
-            return c
-                .filter((b) => typeof b === 'object' &&
-                b !== null &&
-                b.type === 'text' &&
-                typeof b.text === 'string')
-                .map((b) => b.text)
-                .join('\n');
-        };
-        const userMessages = body.messages.filter((m) => m.role === 'user');
-        if (userMessages.length === 0) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(jsonError('at least one message with role "user" is required', 'invalid_request_error'));
-            return;
-        }
-        const traceId = randomUUID();
-        const sessionId = req.headers['x-session-id'] || 'default';
-        const sessionLogger = new SessionLogger(this.cfg.logDir || null, sessionId, traceId);
-        const toolsValidationMode = this.cfg.agent?.externalToolsValidationMode ?? 'permissive';
-        const externalToolsValidation = normalizeAndValidateExternalTools(body.tools);
-        const externalTools = externalToolsValidation.tools;
-        if (externalToolsValidation.errors.length > 0) {
-            log({
-                event: 'invalid_external_tools_detected',
-                traceId,
-                sessionId,
-                mode: toolsValidationMode,
-                count: externalToolsValidation.errors.length,
-                errors: externalToolsValidation.errors,
-            });
-            sessionLogger.logStep('invalid_external_tools_detected', {
-                mode: toolsValidationMode,
-                count: externalToolsValidation.errors.length,
-                errors: externalToolsValidation.errors,
-            });
-            if (toolsValidationMode === 'strict') {
-                const firstError = externalToolsValidation.errors[0];
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(jsonValidationError(firstError.message, firstError.code, firstError.param));
-                return;
-            }
-        }
-        const t0 = Date.now();
-        log({ event: 'request_start', stream: body.stream ?? false, traceId });
-        const opts = {
-            stream: body.stream,
-            externalTools,
-            sessionId,
-            trace: { traceId },
-            sessionLogger,
-            model: body.model,
-            ...(body.temperature !== undefined
-                ? { temperature: body.temperature }
-                : {}),
-            ...(body.max_tokens !== undefined ? { maxTokens: body.max_tokens } : {}),
-            ...(body.top_p !== undefined ? { topP: body.top_p } : {}),
-            ...(body.stop !== undefined
-                ? { stop: Array.isArray(body.stop) ? body.stop : [body.stop] }
-                : {}),
-        };
-        const responseModel = body.model ?? modelProvider?.getModel() ?? 'smart-agent';
-        const normalizedMessages = body.messages
-            .map((m) => {
-            const role = m.role;
-            const normalizedMessage = {
-                role,
-                content: extractText(m.content),
-            };
-            if (role === 'tool') {
-                if (typeof m.tool_call_id === 'string' && m.tool_call_id.trim()) {
-                    normalizedMessage.tool_call_id = m.tool_call_id;
-                }
-                else {
-                    sessionLogger.logStep('drop_orphan_tool_message', {
-                        reason: 'missing_tool_call_id',
-                    });
-                    return null;
-                }
-            }
-            if (role === 'assistant' && Array.isArray(m.tool_calls)) {
-                const toolCalls = m.tool_calls
-                    .filter((tc) => typeof tc === 'object' &&
-                    tc !== null &&
-                    typeof tc.id === 'string' &&
-                    tc.type === 'function' &&
-                    typeof tc.function
-                        ?.name === 'string' &&
-                    typeof tc.function
-                        ?.arguments === 'string')
-                    .map((tc) => ({
-                    id: tc.id,
-                    type: 'function',
-                    function: {
-                        name: tc.function.name,
-                        arguments: tc.function.arguments,
-                    },
-                }));
-                if (toolCalls.length > 0) {
-                    normalizedMessage.tool_calls = toolCalls;
-                    if (!normalizedMessage.content)
-                        normalizedMessage.content = null;
-                }
-            }
-            return normalizedMessage;
-        })
-            .filter((m) => m !== null);
-        const invalidToolsHeader = externalToolsValidation.errors.length > 0
-            ? {
-                'x-smartagent-invalid-tools': String(externalToolsValidation.errors.length),
-            }
-            : {};
-        if (body.stream) {
-            res.writeHead(200, {
-                'Content-Type': 'text/event-stream',
-                'Cache-Control': 'no-cache',
-                Connection: 'keep-alive',
-                ...invalidToolsHeader,
-            });
-            const id = `chatcmpl-${randomUUID()}`;
-            const created = Math.floor(Date.now() / 1000);
-            const stream = smartAgent.streamProcess(normalizedMessages, opts);
-            let firstChunk = true;
-            let finishReasonSent = false;
-            let lastUsage = null;
-            for await (const chunk of stream) {
-                if (!chunk.ok) {
-                    const errorChunk = {
-                        id,
-                        object: 'chat.completion.chunk',
-                        created,
-                        model: responseModel,
-                        choices: [
-                            {
-                                index: 0,
-                                delta: { content: `[Error] ${chunk.error.message}` },
-                                finish_reason: 'stop',
-                            },
-                        ],
-                    };
-                    res.write(`data: ${JSON.stringify(errorChunk)}\n\n`);
-                    finishReasonSent = true;
-                    break;
-                }
-                // SSE heartbeat comment — keeps connection alive, ignored by clients
-                if (chunk.value.heartbeat) {
-                    const hb = chunk.value.heartbeat;
-                    res.write(`: heartbeat tool=${hb.tool} elapsed=${hb.elapsed}ms\n\n`);
-                    continue;
-                }
-                // SSE timing breakdown comment — sent with the final chunk
-                if (chunk.value.timing) {
-                    const parts = chunk.value.timing.map((t) => `${t.phase}=${t.duration}ms`);
-                    res.write(`: timing ${parts.join(' ')}\n\n`);
-                }
-                if (chunk.value.usage) {
-                    lastUsage = {
-                        prompt_tokens: chunk.value.usage.promptTokens,
-                        completion_tokens: chunk.value.usage.completionTokens,
-                        total_tokens: chunk.value.usage.totalTokens,
-                    };
-                }
-                const baseResponse = {
-                    id,
-                    object: 'chat.completion.chunk',
-                    created,
-                    model: responseModel,
-                    usage: null,
-                };
-                if (firstChunk) {
-                    res.write(`data: ${JSON.stringify({ ...baseResponse, choices: [{ index: 0, delta: { role: 'assistant', content: chunk.value.content || '' }, finish_reason: null }] })}\n\n`);
-                    firstChunk = false;
-                    if (!chunk.value.finishReason && !chunk.value.toolCalls)
-                        continue;
-                }
-                if (chunk.value.content || chunk.value.toolCalls) {
-                    const delta = {};
-                    if (chunk.value.content)
-                        delta.content = chunk.value.content;
-                    if (chunk.value.toolCalls) {
-                        delta.tool_calls = chunk.value.toolCalls.map((call, index) => {
-                            const tc = toToolCallDelta(call, index);
-                            return {
-                                index: tc.index,
-                                id: tc.id,
-                                type: 'function',
-                                function: {
-                                    name: tc.name,
-                                    arguments: tc.arguments || '',
-                                },
-                            };
-                        });
-                    }
-                    res.write(`data: ${JSON.stringify({ ...baseResponse, choices: [{ index: 0, delta, finish_reason: null }] })}\n\n`);
-                }
-                if (chunk.value.finishReason) {
-                    res.write(`data: ${JSON.stringify({ ...baseResponse, choices: [{ index: 0, delta: {}, finish_reason: mapStopReason(chunk.value.finishReason) }] })}\n\n`);
-                    finishReasonSent = true;
-                }
-            }
-            if (!finishReasonSent) {
-                const baseResponse = {
-                    id,
-                    object: 'chat.completion.chunk',
-                    created,
-                    model: responseModel,
-                    usage: null,
-                };
-                res.write(`data: ${JSON.stringify({ ...baseResponse, choices: [{ index: 0, delta: {}, finish_reason: 'stop' }] })}\n\n`);
-            }
-            if ((this.cfg.reportUsage !== false ||
-                body.stream_options?.include_usage) &&
-                lastUsage) {
-                res.write(`data: ${JSON.stringify({ id, object: 'chat.completion.chunk', created, model: responseModel, choices: [], usage: lastUsage })}\n\n`);
-            }
-            res.write('data: [DONE]\n\n');
-            res.end();
-            log({
-                event: 'request_done',
-                ok: true,
-                stream: true,
-                finishReason: finishReasonSent ? 'sent' : 'fallback_stop',
-                durationMs: Date.now() - t0,
-            });
-            return;
-        }
-        const result = await smartAgent.process(normalizedMessages, opts);
-        log({ event: 'request_done', ok: result.ok, durationMs: Date.now() - t0 });
-        const finalContent = result.ok
-            ? result.value.content ||
-                (result.value.toolCalls ? null : '(no response)')
-            : `Error: ${result.error.message}`;
-        const finalFinishReason = result.ok
-            ? mapStopReason(result.value.stopReason)
-            : 'stop';
-        let finalUsage = null;
-        if (result.ok && result.value.usage) {
-            finalUsage = {
-                prompt_tokens: result.value.usage.promptTokens,
-                completion_tokens: result.value.usage.completionTokens,
-                total_tokens: result.value.usage.totalTokens,
-            };
-        }
-        const message = {
-            role: 'assistant',
-            content: finalContent,
-        };
-        if (result.ok && result.value.toolCalls) {
-            message.tool_calls = result.value.toolCalls;
-        }
-        res.writeHead(200, {
-            'Content-Type': 'application/json',
-            ...invalidToolsHeader,
-        });
-        res.end(JSON.stringify({
-            id: `chatcmpl-${randomUUID()}`,
-            object: 'chat.completion',
-            created: Math.floor(Date.now() / 1000),
-            model: responseModel,
-            choices: [
-                {
-                    index: 0,
-                    message,
-                    finish_reason: finalFinishReason,
-                },
-            ],
-            usage: finalUsage || {
-                prompt_tokens: 0,
-                completion_tokens: 0,
-                total_tokens: 0,
-            },
-        }));
-    }
-    /** Whitelisted agent config fields allowed via PUT /v1/config. */
-    static AGENT_CONFIG_FIELDS = new Set([
-        'maxIterations',
-        'maxToolCalls',
-        'ragQueryK',
-        'toolUnavailableTtlMs',
-        'showReasoning',
-        'historyAutoSummarizeLimit',
-        'classificationEnabled',
-    ]);
-    async _handleConfigUpdate(req, res, smartAgent) {
-        const raw = await readBody(req);
-        let parsed;
-        try {
-            parsed = JSON.parse(raw);
-        }
-        catch {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(jsonError('Invalid JSON body', 'invalid_request_error'));
-            return;
-        }
-        if (typeof parsed !== 'object' ||
-            parsed === null ||
-            Array.isArray(parsed)) {
-            res.writeHead(400, { 'Content-Type': 'application/json' });
-            res.end(jsonError('Request body must be a JSON object', 'invalid_request_error'));
-            return;
-        }
-        const body = parsed;
-        // --- Validate agent fields against whitelist ---
-        if (body.agent !== undefined) {
-            if (typeof body.agent !== 'object' ||
-                body.agent === null ||
-                Array.isArray(body.agent)) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(jsonError('"agent" must be a JSON object', 'invalid_request_error'));
-                return;
-            }
-            const agentFields = body.agent;
-            const unsupported = Object.keys(agentFields).filter((k) => !SmartServer.AGENT_CONFIG_FIELDS.has(k));
-            if (unsupported.length > 0) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(jsonError(`Unsupported agent config fields: ${unsupported.join(', ')}`, 'invalid_request_error'));
-                return;
-            }
-        }
-        // --- Validate and resolve models (atomic: resolve ALL before mutating) ---
-        let resolvedModels;
-        if (body.models !== undefined) {
-            if (typeof body.models !== 'object' ||
-                body.models === null ||
-                Array.isArray(body.models)) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(jsonError('"models" must be a JSON object', 'invalid_request_error'));
-                return;
-            }
-            if (!this.cfg.modelResolver) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(jsonError('model resolver not configured', 'invalid_request_error'));
-                return;
-            }
-            const modelFields = body.models;
-            const validKeys = new Set([
-                'mainModel',
-                'classifierModel',
-                'helperModel',
-            ]);
-            const unknownKeys = Object.keys(modelFields).filter((k) => !validKeys.has(k));
-            if (unknownKeys.length > 0) {
-                res.writeHead(400, { 'Content-Type': 'application/json' });
-                res.end(jsonError(`Unknown model fields: ${unknownKeys.join(', ')}`, 'invalid_request_error'));
-                return;
-            }
-            try {
-                const resolver = this.cfg.modelResolver;
-                const [mainLlm, classifierLlm, helperLlm] = await Promise.all([
-                    modelFields.mainModel
-                        ? resolver.resolve(String(modelFields.mainModel), 'main')
-                        : undefined,
-                    modelFields.classifierModel
-                        ? resolver.resolve(String(modelFields.classifierModel), 'classifier')
-                        : undefined,
-                    modelFields.helperModel
-                        ? resolver.resolve(String(modelFields.helperModel), 'helper')
-                        : undefined,
-                ]);
-                resolvedModels = {};
-                if (mainLlm)
-                    resolvedModels.mainLlm = mainLlm;
-                if (classifierLlm)
-                    resolvedModels.classifierLlm = classifierLlm;
-                if (helperLlm)
-                    resolvedModels.helperLlm = helperLlm;
-            }
-            catch (err) {
-                res.writeHead(500, { 'Content-Type': 'application/json' });
-                res.end(jsonError(String(err), 'server_error'));
-                return;
-            }
-        }
-        // --- All validation passed — apply mutations ---
-        if (resolvedModels) {
-            smartAgent.reconfigure(resolvedModels);
-        }
-        if (body.agent) {
-            smartAgent.applyConfigUpdate(body.agent);
-        }
-        // --- Return updated config ---
-        const models = smartAgent.getActiveConfig();
-        const agent = smartAgent.getAgentConfig();
-        res.writeHead(200, { 'Content-Type': 'application/json' });
-        res.end(JSON.stringify({ models, agent }));
-    }
-}
-//# sourceMappingURL=smart-server.js.map