@memo-code/memo 0.8.5 → 0.8.6

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

@@ -1,847 +0,0 @@
-"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);