@desktalk/core 0.1.0-alpha.1

package/dist/services/ai/pi-session-service.js

@@ -0,0 +1,697 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { AuthStorage, createAgentSession, DefaultResourceLoader, ModelRegistry, readTool, writeTool, bashTool, grepTool, findTool, lsTool, SessionManager, } from '@mariozechner/pi-coding-agent';
+import { createDesktopTool } from './desktop-tool.js';
+import { createActionTool } from './action-tool.js';
+import { createLiveAppTool } from './create-liveapp-tool.js';
+import { createReadManualTool } from './manual-tool.js';
+import { HtmlStreamCoordinator } from './html-stream-coordinator.js';
+import { createEditTool } from './edit-tool.js';
+import { createUndoEditTool } from './undo-edit-tool.js';
+import { createRedoEditTool } from './redo-edit-tool.js';
+import { ImageGenerationService } from './image-generation-service.js';
+import { createGenerateIconTool } from './generate-icon-tool.js';
+import { EditHistory, createManagedPathResolver } from './edit-history.js';
+import { AI_PROVIDER_DEFINITIONS, getAiProviderPreferences, getAllAiProviderPreferences, getDefaultAiProvider, } from './providers.js';
+import { registry } from '../miniapp-registry.js';
+import { getUserHomeDir } from '../workspace.js';
+import { DESKTALK_SYSTEM_PROMPT } from './system-prompt.js';
+import { listLiveApps } from '../liveapps.js';
+function isUserMessage(message) {
+    return message.role === 'user';
+}
+function isAssistantMessage(message) {
+    return message.role === 'assistant';
+}
+function getMessageKey(role, timestamp) {
+    return `${role}:${timestamp}`;
+}
+/**
+ * Strip the `[Desktop Context]...[/Desktop Context]` block that we prepend
+ * to every user message before sending it to pi. The frontend should never
+ * display this internal metadata.
+ */
+const DESKTOP_CONTEXT_RE = /\[Desktop (?:Context|Content)\][\s\S]*?\[\/Desktop (?:Context|Content)\]\s*/;
+function stripSessionTitleMetadata(text) {
+    return stripDesktopContext(text)
+        .replace(/^\[Desktop (?:Context|Content)\]\s*/i, '')
+        .trim();
+}
+function stripDesktopContext(text) {
+    return text.replace(DESKTOP_CONTEXT_RE, '').trim();
+}
+/**
+ * Build a short summary of generated HTML content for the conversation history.
+ *
+ * This replaces the full HTML string in `ToolCall.arguments.content` so that:
+ * 1. The LLM doesn't re-read (and anchor on) its own previous output.
+ * 2. We save tokens on every subsequent round-trip.
+ *
+ * The summary preserves the document structure (headings, dt-card titles,
+ * tag counts) so the LLM still knows *what* it generated, just not the
+ * exact markup.
+ */
+export function summarizeHtml(html) {
+    const lines = [];
+    // Byte length
+    const bytes = Buffer.byteLength(html, 'utf-8');
+    const sizeLabel = bytes >= 1024 ? `${(bytes / 1024).toFixed(1)} KB` : `${bytes} B`;
+    lines.push(`[HTML content removed from context to save tokens — ${sizeLabel}]`);
+    // Extract <title>
+    const titleMatch = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    if (titleMatch) {
+        lines.push(`Title: ${titleMatch[1].trim()}`);
+    }
+    // Count dt-card elements
+    const cardMatches = html.match(/<dt-card[\s>]/gi);
+    if (cardMatches) {
+        lines.push(`Sections: ${cardMatches.length} dt-card(s)`);
+    }
+    // Extract headings (h1–h6 text, up to 8)
+    const headingRe = /<h([1-6])[^>]*>([\s\S]*?)<\/h\1>/gi;
+    const headings = [];
+    let hMatch;
+    while ((hMatch = headingRe.exec(html)) !== null && headings.length < 8) {
+        const text = hMatch[2].replace(/<[^>]+>/g, '').trim();
+        if (text)
+            headings.push(`  h${hMatch[1]}: ${text}`);
+    }
+    if (headings.length > 0) {
+        lines.push(`Headings:\n${headings.join('\n')}`);
+    }
+    return lines.join('\n');
+}
+/**
+ * Scrub `create_liveapp` tool-call arguments in an assistant message so the
+ * full HTML is not re-sent to the LLM on subsequent turns.
+ *
+ * Mutates `message.content` in-place — this must be called synchronously in
+ * the `message_end` subscriber, **before** session persistence runs.
+ */
+export function scrubHtmlToolCallArgs(message) {
+    for (const block of message.content) {
+        if (block.type === 'toolCall' &&
+            block.name === 'create_liveapp' &&
+            typeof block.arguments?.content === 'string') {
+            const toolCall = block;
+            const originalHtml = toolCall.arguments.content;
+            toolCall.arguments.content = summarizeHtml(originalHtml);
+        }
+    }
+}
+function getMessageText(message) {
+    if (message.role === 'user') {
+        if (typeof message.content === 'string') {
+            return message.content.trim();
+        }
+        return message.content
+            .map((part) => (typeof part.text === 'string' ? part.text : ''))
+            .join('')
+            .trim();
+    }
+    if (message.role === 'assistant') {
+        return message.content
+            .map((part) => {
+            if (part.type === 'text' && typeof part.text === 'string') {
+                return part.text;
+            }
+            return '';
+        })
+            .join('')
+            .trim();
+    }
+    return '';
+}
+function readMetadata(filePath) {
+    if (!existsSync(filePath)) {
+        return { byKey: {} };
+    }
+    try {
+        return JSON.parse(readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return { byKey: {} };
+    }
+}
+function writeMetadata(filePath, store) {
+    mkdirSync(dirname(filePath), { recursive: true });
+    writeFileSync(filePath, JSON.stringify(store, null, 2), 'utf-8');
+}
+function shouldRegisterProviderBaseUrl(provider, baseUrl) {
+    return (Boolean(baseUrl) &&
+        [
+            'azure-openai-responses',
+            'openai',
+            'mistral',
+            'groq',
+            'cerebras',
+            'xai',
+            'openrouter',
+            'vercel-ai-gateway',
+            'huggingface',
+            'ollama',
+        ].includes(provider));
+}
+function normalizeSessionTitle(value) {
+    return stripSessionTitleMetadata(value)
+        .replace(/\s+/g, ' ')
+        .replace(/[.!?]+$/g, '')
+        .trim();
+}
+function generateSessionTitle(prompt) {
+    const normalized = normalizeSessionTitle(prompt)
+        .replace(/^[#>*\-\d.\s]+/, '')
+        .replace(/`+/g, '');
+    if (!normalized) {
+        return 'New session';
+    }
+    if (normalized.length <= 48) {
+        return normalized;
+    }
+    const truncated = normalized.slice(0, 48);
+    const lastSpace = truncated.lastIndexOf(' ');
+    const title = lastSpace >= 24 ? truncated.slice(0, lastSpace) : truncated;
+    return `${title.trim()}...`;
+}
+function toSessionSummary(info, isCurrent) {
+    const fallbackLabel = info.firstMessage.trim() || 'New session';
+    return {
+        id: info.id,
+        label: normalizeSessionTitle(info.name ?? fallbackLabel) ||
+            (isCurrent ? 'Current session' : 'New session'),
+        createdAt: info.created.getTime(),
+        updatedAt: info.modified.getTime(),
+    };
+}
+export class PiSessionService {
+    authStorage;
+    modelRegistry;
+    metadataFilePath;
+    getPreference;
+    session;
+    cwd;
+    sessionDir;
+    resourceLoader;
+    windowManager;
+    htmlStreamCoordinator;
+    log;
+    customTools;
+    getCurrentUsername;
+    constructor(options) {
+        this.session = options.session;
+        this.authStorage = options.authStorage;
+        this.modelRegistry = options.modelRegistry;
+        this.metadataFilePath = options.metadataFilePath;
+        this.getPreference = options.getPreference;
+        this.cwd = options.cwd;
+        this.sessionDir = options.sessionDir;
+        this.resourceLoader = options.resourceLoader;
+        this.windowManager = options.windowManager;
+        this.htmlStreamCoordinator = options.htmlStreamCoordinator;
+        this.log = options.logger;
+        this.customTools = options.customTools;
+        this.getCurrentUsername = options.getCurrentUsername;
+    }
+    static async create(workspacePaths, getPreference, windowManager, invokeAction, sendAiCommand, getCurrentUsername, logger) {
+        const authStorage = AuthStorage.create(join(workspacePaths.config, 'pi-auth.json'));
+        const modelRegistry = new ModelRegistry(authStorage);
+        const sessionDir = join(workspacePaths.data, 'ai-sessions');
+        mkdirSync(sessionDir, { recursive: true });
+        const sessionManager = SessionManager.continueRecent(process.cwd(), sessionDir);
+        const allProviderPreferences = await getAllAiProviderPreferences(getPreference);
+        for (const config of allProviderPreferences) {
+            if (config.apiKey) {
+                authStorage.setRuntimeApiKey(config.provider, config.apiKey);
+            }
+            if (shouldRegisterProviderBaseUrl(config.provider, config.baseUrl)) {
+                modelRegistry.registerProvider(config.provider, {
+                    baseUrl: config.baseUrl,
+                    ...(config.apiKey ? { apiKey: config.apiKey } : {}),
+                    authHeader: config.provider !== 'ollama',
+                });
+            }
+        }
+        const defaultProvider = await getDefaultAiProvider(getPreference);
+        const defaultProviderPreferences = await getAiProviderPreferences(getPreference, defaultProvider);
+        const initialModel = defaultProviderPreferences.model
+            ? modelRegistry.find(defaultProvider, defaultProviderPreferences.model)
+            : modelRegistry.getAvailable().find((model) => model.provider === defaultProvider);
+        const resourceLoader = new DefaultResourceLoader({
+            cwd: process.cwd(),
+            additionalSkillPaths: [join(workspacePaths.data, 'skills')],
+            appendSystemPromptOverride: (base) => [...base, DESKTALK_SYSTEM_PROMPT],
+        });
+        await resourceLoader.reload();
+        const htmlStreamCoordinator = new HtmlStreamCoordinator({
+            sendAiCommand,
+            activateMiniApp: (miniAppId) => {
+                registry.activate(miniAppId, getCurrentUsername());
+            },
+            getPreference,
+            logger: logger.child({ scope: 'html-stream' }),
+        });
+        const resolveManagedPath = (inputPath) => createManagedPathResolver([join(workspacePaths.data, 'home', getCurrentUsername())])(inputPath);
+        const editHistory = new EditHistory(resolveManagedPath);
+        const imageGenerationService = new ImageGenerationService({
+            modelRegistry,
+            getPreference,
+            logger: logger.child({ scope: 'image-generation' }),
+        });
+        const customTools = [
+            createDesktopTool({
+                windowManager,
+                getMiniApps: () => registry.getManifests(),
+                getLiveApps: () => listLiveApps(getUserHomeDir(getCurrentUsername())).map((app) => ({
+                    id: app.id,
+                    name: app.name,
+                })),
+                activateMiniApp: (miniAppId) => {
+                    registry.activate(miniAppId, getCurrentUsername());
+                },
+                sendAiCommand,
+            }),
+            createActionTool({
+                windowManager,
+                invokeAction,
+            }),
+            createLiveAppTool({
+                sendAiCommand,
+                activateMiniApp: (miniAppId) => {
+                    registry.activate(miniAppId, getCurrentUsername());
+                },
+                getPreference,
+                streamCoordinator: htmlStreamCoordinator,
+            }),
+            createGenerateIconTool({
+                imageGenerationService,
+                getCurrentUsername,
+                workspaceDataDir: workspacePaths.data,
+            }),
+            createEditTool({
+                editHistory,
+                resolvePath: resolveManagedPath,
+            }),
+            createUndoEditTool({
+                editHistory,
+                resolvePath: resolveManagedPath,
+            }),
+            createRedoEditTool({
+                editHistory,
+                resolvePath: resolveManagedPath,
+            }),
+            createReadManualTool(),
+        ];
+        const { session } = await createAgentSession({
+            cwd: process.cwd(),
+            authStorage,
+            modelRegistry,
+            model: initialModel,
+            sessionManager,
+            tools: [readTool, writeTool, bashTool, grepTool, findTool, lsTool],
+            customTools,
+            resourceLoader,
+        });
+        return new PiSessionService({
+            session,
+            authStorage,
+            modelRegistry,
+            metadataFilePath: join(workspacePaths.data, 'storage', 'ai-message-metadata.json'),
+            getPreference,
+            cwd: process.cwd(),
+            sessionDir,
+            resourceLoader,
+            windowManager,
+            htmlStreamCoordinator,
+            logger,
+            customTools,
+            getCurrentUsername,
+        });
+    }
+    async createSessionWithManager(sessionManager) {
+        const { session } = await createAgentSession({
+            cwd: this.cwd,
+            authStorage: this.authStorage,
+            modelRegistry: this.modelRegistry,
+            model: this.session.model,
+            sessionManager,
+            tools: [readTool, writeTool, bashTool, grepTool, findTool, lsTool],
+            customTools: this.customTools,
+            resourceLoader: this.resourceLoader,
+        });
+        return session;
+    }
+    getSessionId() {
+        return this.session.sessionId;
+    }
+    async listSessions() {
+        const sessions = await SessionManager.list(this.cwd, this.sessionDir);
+        return sessions
+            .sort((left, right) => right.modified.getTime() - left.modified.getTime())
+            .map((info) => toSessionSummary(info, info.id === this.getSessionId()));
+    }
+    async createNewSession() {
+        this.session = await this.createSessionWithManager(SessionManager.create(this.cwd, this.sessionDir));
+        const summary = (await this.listSessions()).find((session) => session.id === this.getSessionId());
+        return (summary ?? {
+            id: this.getSessionId(),
+            label: 'New session',
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        });
+    }
+    async switchSession(sessionId) {
+        const sessions = await SessionManager.list(this.cwd, this.sessionDir);
+        const target = sessions.find((entry) => entry.id === sessionId);
+        if (!target) {
+            return false;
+        }
+        this.session = await this.createSessionWithManager(SessionManager.open(target.path, this.sessionDir));
+        return true;
+    }
+    async renameCurrentSession(title) {
+        const nextTitle = normalizeSessionTitle(title) || 'New session';
+        this.session.sessionManager.appendSessionInfo(nextTitle);
+        const summary = (await this.listSessions()).find((session) => session.id === this.getSessionId());
+        return (summary ?? {
+            id: this.getSessionId(),
+            label: nextTitle,
+            createdAt: Date.now(),
+            updatedAt: Date.now(),
+        });
+    }
+    async abort() {
+        await this.session.abort();
+    }
+    maybeAssignSessionTitle(inputText) {
+        if (this.session.sessionManager.getSessionName()) {
+            return;
+        }
+        const hasHistory = this.session.messages.some((message) => message.role === 'user');
+        if (hasHistory) {
+            return;
+        }
+        const title = generateSessionTitle(inputText);
+        if (title) {
+            this.session.sessionManager.appendSessionInfo(title);
+        }
+    }
+    async getProviderOptions() {
+        await this.syncProviderCredentials();
+        const defaultProvider = await getDefaultAiProvider(this.getPreference);
+        const availableByProvider = new Set(this.modelRegistry.getAvailable().map((model) => model.provider));
+        const configuredProviders = await getAllAiProviderPreferences(this.getPreference);
+        return {
+            defaultProvider,
+            providers: AI_PROVIDER_DEFINITIONS.map((provider) => {
+                const config = configuredProviders.find((entry) => entry.provider === provider.id);
+                return {
+                    id: provider.id,
+                    label: provider.label,
+                    configured: availableByProvider.has(provider.id) ||
+                        Boolean(config?.model.trim()) ||
+                        Boolean(config?.apiKey.trim()) ||
+                        Boolean(config?.baseUrl.trim()),
+                    model: config?.model ?? '',
+                };
+            }),
+        };
+    }
+    async syncProviderCredentials() {
+        const configuredProviders = await getAllAiProviderPreferences(this.getPreference);
+        for (const config of configuredProviders) {
+            if (config.apiKey) {
+                this.authStorage.setRuntimeApiKey(config.provider, config.apiKey);
+            }
+            else {
+                this.authStorage.removeRuntimeApiKey(config.provider);
+            }
+            if (shouldRegisterProviderBaseUrl(config.provider, config.baseUrl)) {
+                this.modelRegistry.registerProvider(config.provider, {
+                    baseUrl: config.baseUrl,
+                    ...(config.apiKey ? { apiKey: config.apiKey } : {}),
+                    authHeader: config.provider !== 'ollama',
+                });
+            }
+            else {
+                this.modelRegistry.unregisterProvider(config.provider);
+            }
+        }
+    }
+    async syncPreferences(providerOverride) {
+        await this.resourceLoader.reload();
+        await this.syncProviderCredentials();
+        const configuredProvider = providerOverride ?? (await getDefaultAiProvider(this.getPreference));
+        const configuredModel = (await getAiProviderPreferences(this.getPreference, configuredProvider))
+            .model;
+        const targetModel = configuredModel
+            ? this.modelRegistry.find(configuredProvider, configuredModel)
+            : this.modelRegistry.getAvailable().find((model) => model.provider === configuredProvider);
+        if (!targetModel) {
+            throw new Error(configuredModel
+                ? `Configured model not found: ${configuredProvider}/${configuredModel}`
+                : `No model available for ${configuredProvider}. Configure a model in Preferences -> AI.`);
+        }
+        if (!this.session.model ||
+            this.session.model.provider !== targetModel.provider ||
+            this.session.model.id !== targetModel.id) {
+            await this.session.setModel(targetModel);
+        }
+    }
+    saveMessageMetadata(role, timestamp, metadata) {
+        const store = readMetadata(this.metadataFilePath);
+        store.byKey[getMessageKey(role, timestamp)] = metadata;
+        writeMetadata(this.metadataFilePath, store);
+    }
+    getMessageMetadata(role, timestamp) {
+        return readMetadata(this.metadataFilePath).byKey[getMessageKey(role, timestamp)];
+    }
+    getHistory() {
+        const result = [];
+        for (const message of this.session.messages) {
+            if (message.role !== 'user' && message.role !== 'assistant') {
+                continue;
+            }
+            const typedMessage = message;
+            const role = typedMessage.role;
+            const metadata = this.getMessageMetadata(role, typedMessage.timestamp);
+            if (isUserMessage(typedMessage)) {
+                const content = stripDesktopContext(getMessageText(typedMessage));
+                result.push({
+                    id: getMessageKey(role, typedMessage.timestamp),
+                    role,
+                    content,
+                    timestamp: typedMessage.timestamp,
+                    source: metadata?.source ?? 'text',
+                });
+                continue;
+            }
+            if (isAssistantMessage(typedMessage)) {
+                const baseId = getMessageKey(role, typedMessage.timestamp);
+                const assistantFields = {
+                    provider: typedMessage.provider,
+                    model: typedMessage.model,
+                    totalTokens: typedMessage.usage.total,
+                };
+                // Walk through content blocks and emit separate entries for text vs tool calls
+                let textAccumulator = '';
+                let thinkingAccumulator = '';
+                let blockIndex = 0;
+                for (const block of typedMessage.content) {
+                    if (block.type === 'thinking') {
+                        const thinkingBlock = block;
+                        if (typeof thinkingBlock.thinking === 'string') {
+                            thinkingAccumulator += thinkingBlock.thinking;
+                        }
+                    }
+                    else if (block.type === 'text' && typeof block.text === 'string') {
+                        textAccumulator += block.text;
+                    }
+                    else if (block.type === 'toolCall') {
+                        // Flush accumulated text before the tool call
+                        const trimmedText = textAccumulator.trim();
+                        const trimmedThinking = thinkingAccumulator.trim();
+                        if (trimmedText || trimmedThinking) {
+                            result.push({
+                                id: `${baseId}:text-${blockIndex}`,
+                                role,
+                                content: trimmedText,
+                                timestamp: typedMessage.timestamp,
+                                ...assistantFields,
+                                ...(trimmedThinking ? { thinkingContent: trimmedThinking } : {}),
+                            });
+                            blockIndex += 1;
+                        }
+                        textAccumulator = '';
+                        thinkingAccumulator = '';
+                        // Emit tool call as a standalone message
+                        const toolBlock = block;
+                        result.push({
+                            id: `${baseId}:tool-${blockIndex}`,
+                            role,
+                            content: '',
+                            timestamp: typedMessage.timestamp,
+                            ...assistantFields,
+                            toolCall: {
+                                toolName: toolBlock.name,
+                                params: toolBlock.arguments ?? {},
+                            },
+                        });
+                        blockIndex += 1;
+                    }
+                }
+                // Flush any remaining text after the last tool call
+                const trimmedText = textAccumulator.trim();
+                const trimmedThinking = thinkingAccumulator.trim();
+                if (trimmedText || trimmedThinking) {
+                    result.push({
+                        id: blockIndex > 0 ? `${baseId}:text-${blockIndex}` : baseId,
+                        role,
+                        content: trimmedText,
+                        timestamp: typedMessage.timestamp,
+                        ...assistantFields,
+                        ...(trimmedThinking ? { thinkingContent: trimmedThinking } : {}),
+                    });
+                }
+                else if (blockIndex === 0) {
+                    // No content blocks produced anything — emit empty message so the UI
+                    // can show a placeholder if needed
+                    result.push({
+                        id: baseId,
+                        role,
+                        content: '',
+                        timestamp: typedMessage.timestamp,
+                        ...assistantFields,
+                    });
+                }
+            }
+        }
+        return result;
+    }
+    async prompt(input, callbacks) {
+        await this.syncPreferences(input.provider);
+        this.maybeAssignSessionTitle(input.text);
+        const { onEvent } = callbacks;
+        let pendingUserSource = input.source;
+        let currentAssistantText = '';
+        let currentThinkingText = '';
+        const unsubscribe = this.session.subscribe((event) => {
+            if (event.type === 'message_start' &&
+                isAssistantMessage(event.message)) {
+                const message = event.message;
+                currentAssistantText = '';
+                currentThinkingText = '';
+                onEvent({
+                    type: 'message_start',
+                    provider: message.provider,
+                    model: message.model,
+                });
+                return;
+            }
+            if (event.type === 'message_update' &&
+                isAssistantMessage(event.message)) {
+                const message = event.message;
+                const msgEvent = event.assistantMessageEvent;
+                if (msgEvent.type === 'thinking_delta') {
+                    currentThinkingText += msgEvent.delta;
+                    onEvent({
+                        type: 'thinking_update',
+                        thinkingText: currentThinkingText,
+                        provider: message.provider,
+                        model: message.model,
+                    });
+                }
+                if (msgEvent.type === 'text_delta') {
+                    currentAssistantText += msgEvent.delta;
+                    onEvent({
+                        type: 'message_update',
+                        text: currentAssistantText,
+                        provider: message.provider,
+                        model: message.model,
+                    });
+                }
+                // ── HTML streaming via toolcall events ──────────────────────
+                if (msgEvent.type === 'toolcall_start') {
+                    const partialMsg = msgEvent.partial;
+                    const toolContent = partialMsg.content[msgEvent.contentIndex];
+                    this.log.debug({
+                        toolName: toolContent?.name,
+                        toolType: toolContent?.type,
+                        contentIndex: msgEvent.contentIndex,
+                    }, 'toolcall_start received');
+                    if (toolContent &&
+                        toolContent.type === 'toolCall' &&
+                        toolContent.name === 'create_liveapp') {
+                        this.log.debug('detected create_liveapp — calling onToolcallStart()');
+                        this.htmlStreamCoordinator.onToolcallStart();
+                    }
+                }
+                if (msgEvent.type === 'toolcall_delta') {
+                    const session = this.htmlStreamCoordinator.getActiveSession();
+                    if (session && session.state === 'streaming') {
+                        this.htmlStreamCoordinator.onToolcallDelta(msgEvent.delta);
+                    }
+                }
+                // Emit structured tool_call event so the frontend can render it as a standalone row
+                if (msgEvent.type === 'toolcall_end') {
+                    const toolCall = msgEvent.toolCall;
+                    if (toolCall) {
+                        // Reset accumulated text — the text before this tool call is already sent;
+                        // any text after will start fresh.
+                        currentAssistantText = '';
+                        onEvent({
+                            type: 'tool_call',
+                            toolCall: {
+                                toolName: toolCall.name,
+                                params: toolCall.arguments ?? {},
+                            },
+                        });
+                    }
+                }
+                return;
+            }
+            if (event.type === 'message_end') {
+                if (isUserMessage(event.message) && pendingUserSource) {
+                    this.saveMessageMetadata('user', event.message.timestamp, {
+                        source: pendingUserSource,
+                    });
+                    pendingUserSource = null;
+                    return;
+                }
+                if (isAssistantMessage(event.message)) {
+                    const message = event.message;
+                    // Scrub large HTML content from create_liveapp tool calls so it
+                    // is not re-sent on every subsequent LLM round-trip.  This runs
+                    // synchronously before session persistence (step 8c in the event
+                    // pipeline) so both in-memory state and the session file reflect
+                    // the summarised version.
+                    // scrubHtmlToolCallArgs(event.message as unknown as AssistantMessage);
+                    onEvent({
+                        type: 'message_end',
+                        text: getMessageText(message),
+                        provider: message.provider,
+                        model: message.model,
+                        usage: {
+                            totalTokens: message.usage.total,
+                        },
+                    });
+                }
+            }
+        });
+        try {
+            // Prepend the dynamic desktop context to the user's message so the AI
+            // always sees the current windows, MiniApps, and available actions
+            // without requiring an extra tool call.
+            const userHomeDir = getUserHomeDir(this.getCurrentUsername());
+            const desktopContext = this.windowManager.getDesktopContext(registry.getManifests(), listLiveApps(userHomeDir).map((app) => ({
+                id: app.id,
+                name: app.name,
+            })), userHomeDir);
+            const augmentedText = `${desktopContext}\n\n${input.text}`;
+            await this.session.prompt(augmentedText);
+        }
+        finally {
+            unsubscribe();
+        }
+    }
+}
+//# sourceMappingURL=pi-session-service.js.map