@memo-code/memo 0.8.0 → 0.8.5

package/dist/web/server/chat/chat.service.js

@@ -0,0 +1,847 @@
+"use strict";
+var __decorate = (this && this.__decorate) || function (decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+};
+var __metadata = (this && this.__metadata) || function (k, v) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ChatService = void 0;
+const node_crypto_1 = require("node:crypto");
+const promises_1 = require("node:fs/promises");
+const node_path_1 = require("node:path");
+const common_1 = require("@nestjs/common");
+const core_1 = require("@memo-code/core");
+const memo_config_service_1 = require("../config/memo-config.service");
+const sessions_service_1 = require("../sessions/sessions.service");
+const stream_service_1 = require("../stream/stream.service");
+const workspaces_service_1 = require("../workspaces/workspaces.service");
+const MAX_LIVE_SESSIONS = 20;
+function normalizeMode(value) {
+    if (value === 'none' || value === 'once' || value === 'full')
+        return value;
+    return 'once';
+}
+function toAssistantText(turn) {
+    const finalText = turn.finalText?.trim();
+    if (finalText)
+        return finalText;
+    return turn.steps
+        .map((step) => step.assistantText ?? '')
+        .join('')
+        .trim();
+}
+function cloneTurnStep(step) {
+    return {
+        step: step.step,
+        assistantText: step.assistantText,
+        thinking: step.thinking,
+        action: step.action,
+        parallelActions: step.parallelActions,
+        observation: step.observation,
+        resultStatus: step.resultStatus,
+    };
+}
+function cloneTurnSteps(steps) {
+    if (!steps || steps.length === 0)
+        return [];
+    return steps.map(cloneTurnStep);
+}
+async function findTaskPromptTemplate(templateName) {
+    const candidates = [
+        process.env.MEMO_TASK_PROMPTS_DIR
+            ? (0, node_path_1.join)(process.env.MEMO_TASK_PROMPTS_DIR, `${templateName}.md`)
+            : null,
+        (0, node_path_1.join)(process.cwd(), 'dist', 'task-prompts', `${templateName}.md`),
+        (0, node_path_1.join)(process.cwd(), 'packages', 'tui', 'src', 'task-prompts', `${templateName}.md`),
+    ].filter((item) => Boolean(item));
+    for (const filePath of candidates) {
+        const resolved = (0, node_path_1.resolve)(filePath);
+        try {
+            await (0, promises_1.access)(resolved);
+            return (0, promises_1.readFile)(resolved, 'utf8');
+        }
+        catch {
+        }
+    }
+    throw new Error(`Task prompt not found: ${templateName}`);
+}
+function renderTemplate(template, vars) {
+    return template.replace(/{{\s*([\w.-]+)\s*}}/g, (_match, key) => {
+        return vars[key] ?? '';
+    });
+}
+let ChatService = class ChatService {
+    streamService;
+    memoConfigService;
+    sessionsService;
+    workspacesService;
+    sessions = new Map();
+    constructor(streamService, memoConfigService, sessionsService, workspacesService) {
+        this.streamService = streamService;
+        this.memoConfigService = memoConfigService;
+        this.sessionsService = sessionsService;
+        this.workspacesService = workspacesService;
+    }
+    async createSession(input) {
+        if (this.sessions.size >= MAX_LIVE_SESSIONS) {
+            await this.evictOneIdleSession();
+        }
+        const workspace = await this.workspacesService.resolveWorkspace({
+            workspaceId: input.workspaceId,
+            cwd: input.cwd,
+        });
+        await this.workspacesService.touchLastUsed(workspace.id);
+        const config = await this.memoConfigService.load();
+        const provider = this.selectProvider(config.providers, input.providerName, config.current_provider);
+        const sessionId = (0, node_crypto_1.randomUUID)();
+        const runtime = await this.createRuntime({
+            id: sessionId,
+            title: 'New Session',
+            workspaceId: workspace.id,
+            projectName: workspace.name,
+            providerName: provider.name,
+            model: provider.model,
+            cwd: workspace.cwd,
+            startedAt: new Date().toISOString(),
+            activeMcpServers: input.activeMcpServers && input.activeMcpServers.length > 0
+                ? input.activeMcpServers
+                : config.active_mcp_servers,
+            toolPermissionMode: normalizeMode(input.toolPermissionMode),
+        });
+        this.sessions.set(runtime.id, runtime);
+        this.touchSession(runtime);
+        this.streamService.broadcast(runtime.id, {
+            type: 'session.snapshot',
+            payload: this.toState(runtime),
+        });
+        return this.toState(runtime);
+    }
+    async attachSession(sessionId) {
+        const existing = this.sessions.get(sessionId);
+        if (existing) {
+            return this.toSnapshot(existing);
+        }
+        const detail = await this.sessionsService.getSessionDetail(sessionId);
+        const workspace = await this.workspacesService.ensureByCwd(detail.cwd || process.cwd(), detail.project, { validateReadable: false });
+        await this.workspacesService.touchLastUsed(workspace.id);
+        const config = await this.memoConfigService.load();
+        const provider = this.selectProvider(config.providers, undefined, config.current_provider);
+        const historyMessages = [];
+        const turns = [];
+        for (const turn of detail.turns) {
+            const input = (turn.input ?? '').trim();
+            const assistant = toAssistantText(turn);
+            if (input) {
+                historyMessages.push({ role: 'user', content: input });
+            }
+            if (assistant) {
+                historyMessages.push({ role: 'assistant', content: assistant });
+            }
+            turns.push({
+                turn: turn.turn,
+                input,
+                assistant,
+                status: turn.status ?? 'ok',
+                errorMessage: turn.errorMessage,
+                steps: cloneTurnSteps(turn.steps),
+            });
+        }
+        const maxTurn = turns.reduce((max, item) => Math.max(max, item.turn), 0);
+        const runtime = await this.createRuntime({
+            id: detail.sessionId,
+            title: detail.title,
+            workspaceId: workspace.id,
+            projectName: workspace.name,
+            providerName: provider.name,
+            model: provider.model,
+            cwd: workspace.cwd,
+            startedAt: detail.date.startedAt,
+            activeMcpServers: config.active_mcp_servers,
+            toolPermissionMode: 'once',
+            historyFilePath: detail.filePath,
+        });
+        const system = runtime.agentSession.history[0];
+        runtime.agentSession.history = system
+            ? [system, ...historyMessages]
+            : [...historyMessages];
+        runtime.agentSession.turnIndex =
+            maxTurn;
+        runtime.agentSession.sessionStartEmitted = true;
+        runtime.agentSession.title = detail.title;
+        runtime.turn = maxTurn;
+        runtime.turns = turns;
+        this.sessions.set(runtime.id, runtime);
+        this.touchSession(runtime);
+        const snapshot = this.toSnapshot(runtime);
+        this.streamService.broadcast(runtime.id, {
+            type: 'session.snapshot',
+            payload: snapshot.state,
+        });
+        return snapshot;
+    }
+    getSessionState(sessionId) {
+        const session = this.requireSession(sessionId);
+        return this.toState(session);
+    }
+    getSessionSnapshot(sessionId) {
+        const session = this.requireSession(sessionId);
+        return this.toSnapshot(session);
+    }
+    async listProviders() {
+        const config = await this.memoConfigService.load();
+        const current = config.current_provider || config.providers[0]?.name || '';
+        return config.providers.map((provider) => ({
+            name: provider.name,
+            model: provider.model,
+            isCurrent: provider.name === current,
+        }));
+    }
+    async listRuntimeBadges(input) {
+        const workspaceId = input.workspaceId?.trim();
+        const items = Array.from(this.sessions.values())
+            .filter((session) => !workspaceId || session.workspaceId === workspaceId)
+            .map((session) => ({
+            sessionId: session.id,
+            workspaceId: session.workspaceId,
+            status: session.status,
+            updatedAt: session.updatedAt,
+        }))
+            .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt));
+        return { items };
+    }
+    async suggestFiles(input) {
+        const sessionId = input.sessionId?.trim();
+        const workspaceId = input.workspaceId?.trim();
+        if (!sessionId && !workspaceId) {
+            throw new common_1.BadRequestException('sessionId or workspaceId is required');
+        }
+        let cwd = '';
+        if (sessionId) {
+            const active = this.sessions.get(sessionId);
+            if (active) {
+                cwd = active.cwd;
+            }
+            else {
+                const detail = await this.sessionsService.getSessionDetail(sessionId);
+                cwd = detail.cwd || process.cwd();
+            }
+        }
+        else if (workspaceId) {
+            const workspace = await this.workspacesService.resolveWorkspace({
+                workspaceId,
+            });
+            cwd = workspace.cwd;
+        }
+        const limit = typeof input.limit === 'number'
+            ? Math.max(1, Math.min(20, Math.floor(input.limit)))
+            : 8;
+        const items = await (0, core_1.getFileSuggestions)({
+            cwd,
+            query: input.query ?? '',
+            limit,
+            respectGitIgnore: true,
+        });
+        return {
+            items: items.map((item) => ({
+                id: item.id,
+                path: item.path,
+                name: item.name,
+                parent: item.parent,
+                isDir: item.isDir,
+            })),
+        };
+    }
+    hasSession(sessionId) {
+        return this.sessions.has(sessionId);
+    }
+    async deleteSession(sessionId) {
+        const target = sessionId.trim();
+        if (!target) {
+            throw new common_1.BadRequestException('sessionId is required');
+        }
+        if (this.sessions.has(target)) {
+            await this.closeSession(target);
+        }
+        try {
+            await this.sessionsService.removeSession(target);
+        }
+        catch (error) {
+            if (!(error instanceof common_1.NotFoundException)) {
+                throw error;
+            }
+        }
+        return { deleted: true };
+    }
+    async closeSession(sessionId) {
+        const session = this.requireSession(sessionId);
+        this.resolvePendingApprovals(session, 'deny');
+        session.status = 'closed';
+        this.touchSession(session);
+        this.streamService.broadcast(session.id, {
+            type: 'session.status',
+            payload: {
+                status: 'closed',
+                workspaceId: session.workspaceId,
+                updatedAt: session.updatedAt,
+            },
+        });
+        await session.agentSession.close();
+        this.sessions.delete(sessionId);
+        this.streamService.disconnectSession(sessionId);
+        return { closed: true };
+    }
+    async submitInput(sessionId, input) {
+        const session = this.requireSession(sessionId);
+        if (session.status === 'running') {
+            return {
+                accepted: false,
+                kind: 'turn',
+                status: 'error',
+                message: 'Session is busy.',
+            };
+        }
+        const trimmed = input.trim();
+        if (!trimmed) {
+            throw new common_1.BadRequestException('input is required');
+        }
+        if (trimmed.startsWith('/')) {
+            return this.runSlashCommand(session, trimmed);
+        }
+        return this.runCoreTurn(session, trimmed, trimmed);
+    }
+    cancelCurrentTurn(sessionId) {
+        const session = this.requireSession(sessionId);
+        if (session.status === 'running') {
+            session.agentSession.cancelCurrentTurn?.('cancelled by user');
+            return { cancelled: true };
+        }
+        return { cancelled: false };
+    }
+    async compactSession(sessionId) {
+        const session = this.requireSession(sessionId);
+        const result = await session.agentSession.compactHistory('manual');
+        this.streamService.broadcast(session.id, {
+            type: 'system.message',
+            payload: {
+                title: 'Compact',
+                content: result.status === 'success'
+                    ? `Compacted history to ${result.afterTokens} tokens.`
+                    : result.status === 'skipped'
+                        ? 'Skipped compaction: no history to compact.'
+                        : `Compaction failed: ${result.errorMessage ?? 'unknown error'}`,
+            },
+        });
+        return {
+            compacted: result.status === 'success',
+            keptMessages: session.agentSession.history.length,
+        };
+    }
+    applyApprovalDecision(sessionId, fingerprint, decision) {
+        const session = this.requireSession(sessionId);
+        const resolver = session.pendingApprovals.get(fingerprint);
+        if (!resolver) {
+            return { recorded: false };
+        }
+        session.pendingApprovals.delete(fingerprint);
+        if (session.pendingApproval?.fingerprint === fingerprint) {
+            session.pendingApproval = undefined;
+        }
+        resolver(decision);
+        this.touchSession(session);
+        this.streamService.broadcast(session.id, {
+            type: 'session.snapshot',
+            payload: this.toState(session),
+        });
+        return { recorded: true };
+    }
+    async runSlashCommand(session, input) {
+        const config = await this.memoConfigService.load();
+        const result = (0, core_1.resolveSlashCommand)(input, {
+            configPath: this.memoConfigService.getConfigPath(),
+            providerName: session.providerName,
+            model: session.model,
+            mcpServers: config.mcp_servers,
+            providers: config.providers,
+            toolPermissionMode: session.toolPermissionMode,
+        });
+        if (result.kind === 'message') {
+            this.sendSystemMessage(session, result.title, result.content);
+            return { accepted: true, kind: 'command', status: 'ok' };
+        }
+        if (result.kind === 'exit') {
+            await this.closeSession(session.id);
+            return {
+                accepted: true,
+                kind: 'command',
+                status: 'ok',
+                message: 'session closed',
+            };
+        }
+        if (result.kind === 'new') {
+            await this.recreateSessionRuntime(session, {
+                title: 'New Session',
+                resetTurns: true,
+            });
+            this.sendSystemMessage(session, 'New Session', 'Started a fresh session.');
+            return { accepted: true, kind: 'command', status: 'ok' };
+        }
+        if (result.kind === 'switch_model') {
+            await this.recreateSessionRuntime(session, {
+                title: session.title,
+                providerName: result.provider.name,
+                model: result.provider.model,
+            });
+            this.sendSystemMessage(session, 'Models', `Switched to ${result.provider.name} (${result.provider.model}).`);
+            this.streamService.broadcast(session.id, {
+                type: 'session.snapshot',
+                payload: this.toState(session),
+            });
+            return { accepted: true, kind: 'command', status: 'ok' };
+        }
+        if (result.kind === 'set_tool_permission') {
+            await this.recreateSessionRuntime(session, {
+                title: session.title,
+                toolPermissionMode: result.mode,
+            });
+            this.sendSystemMessage(session, 'Tools', `Tool permission set to ${result.mode}.`);
+            this.streamService.broadcast(session.id, {
+                type: 'session.snapshot',
+                payload: this.toState(session),
+            });
+            return { accepted: true, kind: 'command', status: 'ok' };
+        }
+        if (result.kind === 'compact') {
+            await this.compactSession(session.id);
+            return { accepted: true, kind: 'command', status: 'ok' };
+        }
+        if (result.kind === 'init_agents_md') {
+            const template = await findTaskPromptTemplate('init_agents');
+            const prompt = renderTemplate(template, {});
+            return this.runCoreTurn(session, prompt, '/init');
+        }
+        if (result.kind === 'review_pr') {
+            const prNumber = String(result.prNumber);
+            const template = await findTaskPromptTemplate('review_pull_request');
+            const prompt = renderTemplate(template, {
+                pr_number: prNumber,
+                backend_strategy: 'web_server',
+                backend_details: 'Running from memo web server',
+                mcp_server_prefix: 'github',
+            });
+            return this.runCoreTurn(session, prompt, `/review ${prNumber}`);
+        }
+        return { accepted: true, kind: 'command', status: 'ok' };
+    }
+    async runCoreTurn(session, prompt, displayInput) {
+        session.nextInputDisplay = displayInput;
+        try {
+            const result = await session.agentSession.runTurn(prompt);
+            return {
+                accepted: true,
+                kind: 'turn',
+                status: result.status === 'ok'
+                    ? 'ok'
+                    : result.status === 'cancelled'
+                        ? 'cancelled'
+                        : 'error',
+                message: result.errorMessage,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            session.status = 'idle';
+            this.touchSession(session);
+            this.streamService.broadcast(session.id, {
+                type: 'error',
+                payload: {
+                    code: 'turn_error',
+                    message,
+                },
+            });
+            this.streamService.broadcast(session.id, {
+                type: 'session.status',
+                payload: {
+                    status: 'idle',
+                    workspaceId: session.workspaceId,
+                    updatedAt: session.updatedAt,
+                },
+            });
+            return {
+                accepted: true,
+                kind: 'turn',
+                status: 'error',
+                message,
+            };
+        }
+    }
+    async recreateSessionRuntime(session, options) {
+        this.resolvePendingApprovals(session, 'deny');
+        await session.agentSession.close();
+        if (options.providerName)
+            session.providerName = options.providerName;
+        if (options.model)
+            session.model = options.model;
+        if (options.toolPermissionMode) {
+            session.toolPermissionMode = options.toolPermissionMode;
+        }
+        if (options.activeMcpServers) {
+            session.activeMcpServers = options.activeMcpServers;
+        }
+        if (options.title) {
+            session.title = options.title;
+        }
+        if (options.resetTurns) {
+            session.turn = 0;
+            session.turns = [];
+        }
+        session.agentSession = await this.createCoreSession(session);
+        if (!options.resetTurns) {
+            this.restoreAgentHistoryFromTurns(session);
+        }
+        session.status = 'idle';
+        this.touchSession(session);
+    }
+    restoreAgentHistoryFromTurns(session) {
+        if (!session.turns.length)
+            return;
+        const historyMessages = [];
+        let maxTurn = 0;
+        const sorted = [...session.turns].sort((a, b) => a.turn - b.turn);
+        for (const turn of sorted) {
+            maxTurn = Math.max(maxTurn, turn.turn);
+            const input = turn.input.trim();
+            const assistant = turn.assistant.trim();
+            if (input) {
+                historyMessages.push({ role: 'user', content: input });
+            }
+            if (assistant) {
+                historyMessages.push({ role: 'assistant', content: assistant });
+            }
+        }
+        const system = session.agentSession.history[0];
+        session.agentSession.history = system
+            ? [system, ...historyMessages]
+            : [...historyMessages];
+        session.agentSession.turnIndex =
+            maxTurn;
+        session.agentSession.sessionStartEmitted = true;
+        session.agentSession.title = session.title;
+        session.turn = maxTurn;
+    }
+    async createRuntime(input) {
+        const runtime = {
+            id: input.id,
+            title: input.title,
+            workspaceId: input.workspaceId,
+            projectName: input.projectName,
+            providerName: input.providerName,
+            model: input.model,
+            cwd: input.cwd,
+            startedAt: input.startedAt,
+            updatedAt: new Date().toISOString(),
+            status: 'idle',
+            activeMcpServers: input.activeMcpServers,
+            toolPermissionMode: input.toolPermissionMode,
+            turn: 0,
+            historyFilePath: input.historyFilePath,
+            turns: [],
+            pendingApprovals: new Map(),
+            agentSession: null,
+        };
+        runtime.agentSession = await this.createCoreSession(runtime);
+        runtime.historyFilePath =
+            runtime.historyFilePath ?? runtime.agentSession.historyFilePath;
+        return runtime;
+    }
+    async createCoreSession(runtime) {
+        const deps = {
+            historySinks: runtime.historyFilePath
+                ? [new core_1.JsonlHistorySink(runtime.historyFilePath)]
+                : undefined,
+            onAssistantStep: (chunk, step) => {
+                if (!chunk)
+                    return;
+                const turn = runtime.activeTurn;
+                if (!turn)
+                    return;
+                const record = this.getOrCreateTurnRecord(runtime, turn);
+                const stepRecord = this.getOrCreateTurnStep(record, step);
+                record.assistant = `${record.assistant}${chunk}`;
+                stepRecord.assistantText = `${stepRecord.assistantText ?? ''}${chunk}`;
+                this.streamService.broadcast(runtime.id, {
+                    type: 'assistant.chunk',
+                    payload: {
+                        turn,
+                        step,
+                        chunk,
+                    },
+                });
+            },
+            requestApproval: async (request) => {
+                runtime.pendingApproval = request;
+                this.touchSession(runtime);
+                this.streamService.broadcast(runtime.id, {
+                    type: 'approval.request',
+                    payload: {
+                        fingerprint: request.fingerprint,
+                        toolName: request.toolName,
+                        reason: request.reason,
+                        riskLevel: request.riskLevel,
+                        params: request.params,
+                    },
+                });
+                this.streamService.broadcast(runtime.id, {
+                    type: 'session.snapshot',
+                    payload: this.toState(runtime),
+                });
+                return new Promise((resolve) => {
+                    runtime.pendingApprovals.set(request.fingerprint, resolve);
+                });
+            },
+            hooks: {
+                onTurnStart: ({ turn, input }) => {
+                    runtime.status = 'running';
+                    runtime.activeTurn = turn;
+                    runtime.turn = Math.max(runtime.turn, turn);
+                    const displayInput = runtime.nextInputDisplay ?? input;
+                    runtime.nextInputDisplay = undefined;
+                    const record = this.getOrCreateTurnRecord(runtime, turn);
+                    record.input = displayInput;
+                    record.assistant = '';
+                    record.status = 'running';
+                    record.errorMessage = undefined;
+                    record.steps = [];
+                    this.touchSession(runtime);
+                    this.streamService.broadcast(runtime.id, {
+                        type: 'session.status',
+                        payload: {
+                            status: 'running',
+                            workspaceId: runtime.workspaceId,
+                            updatedAt: runtime.updatedAt,
+                        },
+                    });
+                    this.streamService.broadcast(runtime.id, {
+                        type: 'turn.start',
+                        payload: {
+                            turn,
+                            input: displayInput,
+                        },
+                    });
+                },
+                onAction: ({ turn, step, action, parallelActions, thinking }) => {
+                    const record = this.getOrCreateTurnRecord(runtime, turn);
+                    const stepRecord = this.getOrCreateTurnStep(record, step);
+                    stepRecord.action = action;
+                    stepRecord.parallelActions =
+                        parallelActions && parallelActions.length > 1
+                            ? parallelActions
+                            : undefined;
+                    stepRecord.thinking = thinking;
+                    this.streamService.broadcast(runtime.id, {
+                        type: 'tool.action',
+                        payload: {
+                            turn,
+                            step,
+                            action,
+                            parallelActions: parallelActions && parallelActions.length > 0
+                                ? parallelActions
+                                : undefined,
+                            thinking,
+                        },
+                    });
+                },
+                onObservation: ({ turn, step, observation, resultStatus, parallelResultStatuses, }) => {
+                    const record = this.getOrCreateTurnRecord(runtime, turn);
+                    const stepRecord = this.getOrCreateTurnStep(record, step);
+                    stepRecord.observation = observation;
+                    stepRecord.resultStatus =
+                        typeof resultStatus === 'string'
+                            ? resultStatus
+                            : parallelResultStatuses?.[0];
+                    this.streamService.broadcast(runtime.id, {
+                        type: 'tool.observation',
+                        payload: {
+                            turn,
+                            step,
+                            observation,
+                            resultStatus,
+                            parallelResultStatuses,
+                        },
+                    });
+                },
+                onFinal: ({ turn, finalText, status, errorMessage }) => {
+                    runtime.activeTurn = undefined;
+                    runtime.status = 'idle';
+                    const record = this.getOrCreateTurnRecord(runtime, turn);
+                    record.assistant = finalText || record.assistant;
+                    record.status = status;
+                    record.errorMessage = errorMessage;
+                    this.touchSession(runtime);
+                    this.streamService.broadcast(runtime.id, {
+                        type: 'turn.final',
+                        payload: {
+                            turn,
+                            finalText,
+                            status,
+                            errorMessage,
+                        },
+                    });
+                    this.streamService.broadcast(runtime.id, {
+                        type: 'session.status',
+                        payload: {
+                            status: 'idle',
+                            workspaceId: runtime.workspaceId,
+                            updatedAt: runtime.updatedAt,
+                        },
+                    });
+                    this.streamService.broadcast(runtime.id, {
+                        type: 'session.snapshot',
+                        payload: this.toState(runtime),
+                    });
+                },
+                onTitleGenerated: ({ title }) => {
+                    runtime.title = title;
+                    this.touchSession(runtime);
+                    this.streamService.broadcast(runtime.id, {
+                        type: 'session.snapshot',
+                        payload: this.toState(runtime),
+                    });
+                },
+                onApprovalResponse: ({ fingerprint }) => {
+                    runtime.pendingApprovals.delete(fingerprint);
+                    if (runtime.pendingApproval?.fingerprint === fingerprint) {
+                        runtime.pendingApproval = undefined;
+                    }
+                    this.touchSession(runtime);
+                    this.streamService.broadcast(runtime.id, {
+                        type: 'session.snapshot',
+                        payload: this.toState(runtime),
+                    });
+                },
+            },
+        };
+        return (0, core_1.createAgentSession)(deps, {
+            sessionId: runtime.id,
+            mode: 'interactive',
+            providerName: runtime.providerName,
+            activeMcpServers: runtime.activeMcpServers,
+            toolPermissionMode: runtime.toolPermissionMode,
+            dangerous: runtime.toolPermissionMode === 'full',
+            cwd: runtime.cwd,
+        });
+    }
+    getOrCreateTurnRecord(runtime, turn) {
+        let record = runtime.turns.find((item) => item.turn === turn);
+        if (record)
+            return record;
+        record = {
+            turn,
+            input: '',
+            assistant: '',
+            status: 'running',
+            steps: [],
+        };
+        runtime.turns.push(record);
+        return record;
+    }
+    getOrCreateTurnStep(record, step) {
+        let entry = record.steps.find((item) => item.step === step);
+        if (entry)
+            return entry;
+        entry = { step };
+        record.steps.push(entry);
+        record.steps.sort((a, b) => a.step - b.step);
+        return entry;
+    }
+    resolvePendingApprovals(session, decision) {
+        for (const resolver of session.pendingApprovals.values()) {
+            resolver(decision);
+        }
+        session.pendingApprovals.clear();
+        session.pendingApproval = undefined;
+    }
+    sendSystemMessage(session, title, content) {
+        this.streamService.broadcast(session.id, {
+            type: 'system.message',
+            payload: {
+                title,
+                content,
+            },
+        });
+    }
+    touchSession(session) {
+        session.updatedAt = new Date().toISOString();
+    }
+    requireSession(sessionId) {
+        const session = this.sessions.get(sessionId);
+        if (!session) {
+            throw new common_1.NotFoundException('Live session not found');
+        }
+        return session;
+    }
+    toState(session) {
+        return {
+            id: session.id,
+            title: session.title,
+            workspaceId: session.workspaceId,
+            projectName: session.projectName,
+            providerName: session.providerName,
+            model: session.model,
+            cwd: session.cwd,
+            startedAt: session.startedAt,
+            status: session.status,
+            pendingApproval: session.pendingApproval
+                ? {
+                    fingerprint: session.pendingApproval.fingerprint,
+                    toolName: session.pendingApproval.toolName,
+                    reason: session.pendingApproval.reason,
+                    riskLevel: session.pendingApproval.riskLevel,
+                    params: session.pendingApproval.params,
+                }
+                : undefined,
+            activeMcpServers: session.activeMcpServers,
+            toolPermissionMode: session.toolPermissionMode,
+        };
+    }
+    toSnapshot(session) {
+        return {
+            state: this.toState(session),
+            turns: session.turns.map((turn) => ({
+                turn: turn.turn,
+                input: turn.input,
+                assistant: turn.assistant,
+                status: turn.status,
+                errorMessage: turn.errorMessage,
+                steps: cloneTurnSteps(turn.steps),
+            })),
+        };
+    }
+    selectProvider(providers, preferredName, fallbackName) {
+        const candidate = preferredName || fallbackName;
+        const found = providers.find((provider) => provider.name === candidate);
+        if (found)
+            return found;
+        if (providers.length > 0)
+            return providers[0];
+        throw new common_1.ServiceUnavailableException('No providers configured in memo config.');
+    }
+    async evictOneIdleSession() {
+        const idle = Array.from(this.sessions.values()).find((session) => session.status === 'idle');
+        if (!idle) {
+            throw new common_1.ServiceUnavailableException(`Too many live sessions (max=${MAX_LIVE_SESSIONS}).`);
+        }
+        await this.closeSession(idle.id);
+    }
+};
+exports.ChatService = ChatService;
+exports.ChatService = ChatService = __decorate([
+    (0, common_1.Injectable)(),
+    __metadata("design:paramtypes", [stream_service_1.StreamService,
+        memo_config_service_1.MemoConfigService,
+        sessions_service_1.SessionsService,
+        workspaces_service_1.WorkspacesService])
+], ChatService);