@getpaseo/server 0.1.2 → 0.1.3

package/dist/server/server/session.js

@@ -6,7 +6,6 @@ import { promisify } from "util";
 import { join, resolve, sep } from "path";
 import { z } from "zod";
 import { serializeAgentStreamEvent, } from "./messages.js";
-import { parseAndHighlightDiff } from "./utils/diff-highlighter.js";
 import { TTSManager } from "./agent/tts-manager.js";
 import { STTManager } from "./agent/stt-manager.js";
 import { maybePersistTtsDebugAudio } from "./agent/tts-debug.js";
@@ -261,7 +260,7 @@ export class Session {
         // Initialize agent MCP client asynchronously
         void this.initializeAgentMcp();
         this.subscribeToAgentEvents();
-        this.sessionLogger.info("Session created");
+        this.sessionLogger.trace("Session created");
     }
     /**
      * Get the client's current activity state
@@ -331,11 +330,11 @@ export class Session {
     /**
      * Start streaming an agent run and forward results via the websocket broadcast
      */
-    startAgentStream(agentId, prompt) {
+    startAgentStream(agentId, prompt, runOptions) {
         this.sessionLogger.info({ agentId }, `Starting agent stream for ${agentId}`);
         let iterator;
         try {
-            iterator = this.agentManager.streamAgent(agentId, prompt);
+            iterator = this.agentManager.streamAgent(agentId, prompt, runOptions);
         }
         catch (error) {
             this.handleAgentRunError(agentId, error, "Failed to start agent run");
@@ -379,7 +378,7 @@ export class Session {
             });
             this.agentTools = (await this.agentMcpClient.tools());
             const agentToolCount = Object.keys(this.agentTools ?? {}).length;
-            this.sessionLogger.info({ agentToolCount }, `Agent MCP initialized with ${agentToolCount} tools`);
+            this.sessionLogger.trace({ agentToolCount }, `Agent MCP initialized with ${agentToolCount} tools`);
         }
         catch (error) {
             this.sessionLogger.error({ err: error }, "Failed to initialize Agent MCP");
@@ -534,10 +533,12 @@ export class Session {
             let snapshot;
             if (handle) {
                 snapshot = await this.agentManager.resumeAgentFromPersistence(handle, buildConfigOverrides(record), agentId, extractTimestamps(record));
+                this.sessionLogger.info({ agentId, provider: record.provider }, "Agent resumed from persistence");
             }
             else {
                 const config = buildSessionConfig(record);
                 snapshot = await this.agentManager.createAgent(config, agentId, { labels: record.labels });
+                this.sessionLogger.info({ agentId, provider: record.provider }, "Agent created from stored config");
             }
             await this.agentManager.hydrateTimelineFromProvider(agentId);
             return this.agentManager.getAgent(agentId) ?? snapshot;
@@ -685,6 +686,9 @@ export class Session {
                 case "archive_agent_request":
                     await this.handleArchiveAgentRequest(msg.agentId, msg.requestId);
                     break;
+                case "update_agent_request":
+                    await this.handleUpdateAgentRequest(msg.agentId, msg.name, msg.labels, msg.requestId);
+                    break;
                 case "set_voice_mode":
                     await this.handleSetVoiceMode(msg.enabled, msg.agentId, msg.requestId);
                     break;
@@ -741,9 +745,6 @@ export class Session {
                 case "agent_permission_response":
                     await this.handleAgentPermissionResponse(msg.agentId, msg.requestId, msg.response);
                     break;
-                case "git_diff_request":
-                    await this.handleGitDiffRequest(msg.agentId, msg.requestId);
-                    break;
                 case "checkout_status_request":
                     await this.handleCheckoutStatusRequest(msg);
                     break;
@@ -780,9 +781,6 @@ export class Session {
                 case "paseo_worktree_archive_request":
                     await this.handlePaseoWorktreeArchiveRequest(msg);
                     break;
-                case "highlighted_diff_request":
-                    await this.handleHighlightedDiffRequest(msg.agentId, msg.requestId);
-                    break;
                 case "file_explorer_request":
                     await this.handleFileExplorerRequest(msg);
                     break;
@@ -795,6 +793,9 @@ export class Session {
                 case "list_provider_models_request":
                     await this.handleListProviderModelsRequest(msg);
                     break;
+                case "list_available_providers_request":
+                    await this.handleListAvailableProvidersRequest(msg);
+                    break;
                 case "speech_models_list_request":
                     await this.handleSpeechModelsListRequest(msg);
                     break;
@@ -965,6 +966,72 @@ export class Session {
             },
         });
     }
+    async handleUpdateAgentRequest(agentId, name, labels, requestId) {
+        this.sessionLogger.info({ agentId, requestId, hasName: typeof name === "string", labelCount: labels ? Object.keys(labels).length : 0 }, "session: update_agent_request");
+        const normalizedName = name?.trim();
+        const normalizedLabels = labels && Object.keys(labels).length > 0 ? labels : undefined;
+        if (!normalizedName && !normalizedLabels) {
+            this.emit({
+                type: "update_agent_response",
+                payload: {
+                    requestId,
+                    agentId,
+                    accepted: false,
+                    error: "Nothing to update (provide name and/or labels)",
+                },
+            });
+            return;
+        }
+        try {
+            const liveAgent = this.agentManager.getAgent(agentId);
+            if (liveAgent) {
+                if (normalizedName) {
+                    await this.agentManager.setTitle(agentId, normalizedName);
+                }
+                if (normalizedLabels) {
+                    await this.agentManager.setLabels(agentId, normalizedLabels);
+                }
+            }
+            else {
+                const existing = await this.agentStorage.get(agentId);
+                if (!existing) {
+                    throw new Error(`Agent not found: ${agentId}`);
+                }
+                await this.agentStorage.upsert({
+                    ...existing,
+                    ...(normalizedName ? { title: normalizedName } : {}),
+                    ...(normalizedLabels
+                        ? { labels: { ...existing.labels, ...normalizedLabels } }
+                        : {}),
+                });
+            }
+            this.emit({
+                type: "update_agent_response",
+                payload: { requestId, agentId, accepted: true, error: null },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error, agentId, requestId }, "session: update_agent_request error");
+            this.emit({
+                type: "activity_log",
+                payload: {
+                    id: uuidv4(),
+                    timestamp: new Date(),
+                    type: "error",
+                    content: `Failed to update agent: ${error.message}`,
+                },
+            });
+            this.emit({
+                type: "update_agent_response",
+                payload: {
+                    requestId,
+                    agentId,
+                    accepted: false,
+                    error: error?.message ? String(error.message) : "Failed to update agent",
+                },
+            });
+        }
+    }
     /**
      * Handle voice mode toggle
      */
@@ -1318,7 +1385,7 @@ export class Session {
     /**
      * Handle text message to agent (with optional image attachments)
      */
-    async handleSendAgentMessage(agentId, text, messageId, images) {
+    async handleSendAgentMessage(agentId, text, messageId, images, runOptions) {
         this.sessionLogger.info({ agentId, textPreview: text.substring(0, 50), imageCount: images?.length ?? 0 }, `Sending text to agent ${agentId}${images && images.length > 0 ? ` with ${images.length} image attachment(s)` : ''}`);
         try {
             await this.ensureAgentLoaded(agentId);
@@ -1341,13 +1408,12 @@ export class Session {
         catch (error) {
             this.sessionLogger.error({ err: error, agentId }, `Failed to record user message for agent ${agentId}`);
         }
-        this.startAgentStream(agentId, prompt);
+        this.startAgentStream(agentId, prompt, runOptions);
     }
     /**
      * Handle on-demand agent initialization request from client
      */
     async handleInitializeAgentRequest(agentId, requestId) {
-        this.sessionLogger.info({ agentId }, `Initializing agent ${agentId} on demand`);
         try {
             const snapshot = await this.ensureAgentLoaded(agentId);
             await this.forwardAgentUpdate(snapshot);
@@ -1362,7 +1428,6 @@ export class Session {
                     requestId,
                 },
             });
-            this.sessionLogger.info({ agentId, timelineSize, status: snapshot.lifecycle }, `Agent ${agentId} initialized with ${timelineSize} timeline item(s); status=${snapshot.lifecycle}`);
         }
         catch (error) {
             this.sessionLogger.error({ err: error, agentId }, `Failed to initialize agent ${agentId}`);
@@ -1380,7 +1445,7 @@ export class Session {
      * Handle create agent request
      */
     async handleCreateAgentRequest(msg) {
-        const { config, worktreeName, requestId, initialPrompt, git, images, labels } = msg;
+        const { config, worktreeName, requestId, initialPrompt, outputSchema, git, images, labels } = msg;
         this.sessionLogger.info({ cwd: config.cwd, provider: config.provider, worktreeName }, `Creating agent in ${config.cwd} (${config.provider})${worktreeName ? ` with worktree ${worktreeName}` : ""}`);
         try {
             const { sessionConfig, worktreeConfig } = await this.buildAgentSessionConfig(config, git, worktreeName, labels);
@@ -1398,7 +1463,7 @@ export class Session {
                     logger: this.sessionLogger,
                 });
                 try {
-                    await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, uuidv4(), images);
+                    await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, uuidv4(), images, outputSchema ? { outputSchema } : undefined);
                 }
                 catch (promptError) {
                     this.sessionLogger.error({ err: promptError, agentId: snapshot.id }, `Failed to run initial prompt for agent ${snapshot.id}`);
@@ -1752,6 +1817,33 @@ export class Session {
             });
         }
     }
+    async handleListAvailableProvidersRequest(msg) {
+        const fetchedAt = new Date().toISOString();
+        try {
+            const providers = await this.agentManager.listProviderAvailability();
+            this.emit({
+                type: "list_available_providers_response",
+                payload: {
+                    providers,
+                    error: null,
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+        catch (error) {
+            this.sessionLogger.error({ err: error }, "Failed to list provider availability");
+            this.emit({
+                type: "list_available_providers_response",
+                payload: {
+                    providers: [],
+                    error: error?.message ?? String(error),
+                    fetchedAt,
+                    requestId: msg.requestId,
+                },
+            });
+        }
+    }
     async handleSpeechModelsListRequest(msg) {
         const modelsDir = this.localSpeechModelsDir;
         const models = await Promise.all(listLocalSpeechModels().map(async (model) => {
@@ -2377,52 +2469,6 @@ export class Session {
             throw error;
         }
     }
-    /**
-     * Handle git diff request for an agent
-     */
-    async handleGitDiffRequest(agentId, requestId) {
-        this.sessionLogger.debug({ agentId }, `Handling git diff request for agent ${agentId}`);
-        try {
-            const agents = this.agentManager.listAgents();
-            const agent = agents.find((a) => a.id === agentId);
-            if (!agent) {
-                this.emit({
-                    type: "git_diff_response",
-                    payload: {
-                        agentId,
-                        diff: "",
-                        error: `Agent not found: ${agentId}`,
-                        requestId,
-                    },
-                });
-                return;
-            }
-            const diffResult = await getCheckoutDiff(agent.cwd, { mode: "uncommitted" }, { paseoHome: this.paseoHome });
-            const combinedDiff = diffResult.diff;
-            this.emit({
-                type: "git_diff_response",
-                payload: {
-                    agentId,
-                    diff: combinedDiff,
-                    error: null,
-                    requestId,
-                },
-            });
-            this.sessionLogger.debug({ agentId, diffBytes: combinedDiff.length }, `Git diff for agent ${agentId} completed (${combinedDiff.length} bytes)`);
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, agentId }, `Failed to get git diff for agent ${agentId}`);
-            this.emit({
-                type: "git_diff_response",
-                payload: {
-                    agentId,
-                    diff: "",
-                    error: error.message,
-                    requestId,
-                },
-            });
-        }
-    }
     async handleCheckoutStatusRequest(msg) {
         const { cwd, requestId } = msg;
         try {
@@ -3051,12 +3097,13 @@ export class Session {
     async handleCheckoutPrStatusRequest(msg) {
         const { cwd, requestId } = msg;
         try {
-            const status = await getPullRequestStatus(cwd);
+            const prStatus = await getPullRequestStatus(cwd);
             this.emit({
                 type: "checkout_pr_status_response",
                 payload: {
                     cwd,
-                    status,
+                    status: prStatus.status,
+                    githubFeaturesEnabled: prStatus.githubFeaturesEnabled,
                     error: null,
                     requestId,
                 },
@@ -3068,6 +3115,7 @@ export class Session {
                 payload: {
                     cwd,
                     status: null,
+                    githubFeaturesEnabled: true,
                     error: this.toCheckoutError(error),
                     requestId,
                 },
@@ -3223,185 +3271,6 @@ export class Session {
             });
         }
     }
-    /**
-     * Handle highlighted diff request - returns parsed and syntax-highlighted diff
-     */
-    async handleHighlightedDiffRequest(agentId, requestId) {
-        this.sessionLogger.debug({ agentId }, `Handling highlighted diff request for agent ${agentId}`);
-        // Maximum lines changed before we skip showing the diff content
-        const MAX_DIFF_LINES = 5000;
-        try {
-            const agents = this.agentManager.listAgents();
-            const agent = agents.find((a) => a.id === agentId);
-            if (!agent) {
-                this.emit({
-                    type: "highlighted_diff_response",
-                    payload: {
-                        agentId,
-                        files: [],
-                        error: `Agent not found: ${agentId}`,
-                        requestId,
-                    },
-                });
-                return;
-            }
-            // Step 1: Get the list of changed files with their stats (numstat gives additions/deletions per file)
-            const { stdout: numstatOutput } = await execAsync("git diff --numstat HEAD", { cwd: agent.cwd });
-            // Get file statuses (A=added, D=deleted, M=modified) to detect deleted files
-            const { stdout: nameStatusOutput } = await execAsync("git diff --name-status HEAD", { cwd: agent.cwd });
-            const deletedFiles = new Set();
-            const addedFiles = new Set();
-            for (const line of nameStatusOutput.trim().split("\n").filter(Boolean)) {
-                const [status, ...pathParts] = line.split("\t");
-                const path = pathParts.join("\t");
-                if (status === "D") {
-                    deletedFiles.add(path);
-                }
-                else if (status === "A") {
-                    addedFiles.add(path);
-                }
-            }
-            const fileStats = [];
-            for (const line of numstatOutput.trim().split("\n").filter(Boolean)) {
-                const parts = line.split("\t");
-                if (parts.length >= 3) {
-                    const [addStr, delStr, ...pathParts] = parts;
-                    const path = pathParts.join("\t"); // Handle paths with tabs
-                    const isBinary = addStr === "-" && delStr === "-";
-                    fileStats.push({
-                        path,
-                        additions: isBinary ? 0 : parseInt(addStr, 10),
-                        deletions: isBinary ? 0 : parseInt(delStr, 10),
-                        isBinary,
-                        isTracked: true,
-                        isDeleted: deletedFiles.has(path),
-                        isNew: addedFiles.has(path),
-                    });
-                }
-            }
-            // Step 2: Get untracked files
-            try {
-                const { stdout: untrackedFiles } = await execAsync("git ls-files --others --exclude-standard", { cwd: agent.cwd });
-                for (const filePath of untrackedFiles.trim().split("\n").filter(Boolean)) {
-                    // Use git's numstat with --no-index to detect binary files (cross-platform)
-                    // Binary files show as "-\t-\tfilepath", text files show line counts
-                    try {
-                        const { stdout: numstatLine } = await execAsync(`git diff --numstat --no-index /dev/null "${filePath}" || true`, { cwd: agent.cwd });
-                        const parts = numstatLine.trim().split("\t");
-                        const isBinary = parts[0] === "-" && parts[1] === "-";
-                        const additions = isBinary ? 0 : (parseInt(parts[0], 10) || 0);
-                        fileStats.push({
-                            path: filePath,
-                            additions,
-                            deletions: 0,
-                            isBinary,
-                            isTracked: false,
-                            isDeleted: false,
-                            isNew: true,
-                        });
-                    }
-                    catch {
-                        // If we can't determine, assume text and try to get it
-                        fileStats.push({
-                            path: filePath,
-                            additions: 0,
-                            deletions: 0,
-                            isBinary: false,
-                            isTracked: false,
-                            isDeleted: false,
-                            isNew: true,
-                        });
-                    }
-                }
-            }
-            catch {
-                // Ignore errors getting untracked files
-            }
-            // Step 3: Fetch diffs per-file, respecting limits
-            const allFiles = [];
-            for (const stats of fileStats) {
-                const totalLines = stats.additions + stats.deletions;
-                // Handle binary files
-                if (stats.isBinary) {
-                    allFiles.push({
-                        path: stats.path,
-                        isNew: stats.isNew,
-                        isDeleted: stats.isDeleted,
-                        additions: 0,
-                        deletions: 0,
-                        hunks: [],
-                        status: "binary",
-                    });
-                    continue;
-                }
-                // Handle files that are too large
-                if (totalLines > MAX_DIFF_LINES) {
-                    allFiles.push({
-                        path: stats.path,
-                        isNew: stats.isNew,
-                        isDeleted: stats.isDeleted,
-                        additions: stats.additions,
-                        deletions: stats.deletions,
-                        hunks: [],
-                        status: "too_large",
-                    });
-                    continue;
-                }
-                // Fetch the actual diff for this file
-                try {
-                    let fileDiff;
-                    if (stats.isTracked) {
-                        const { stdout } = await execAsync(`git diff HEAD -- "${stats.path}"`, { cwd: agent.cwd });
-                        fileDiff = stdout;
-                    }
-                    else {
-                        const { stdout } = await execAsync(`git diff --no-index /dev/null "${stats.path}" || true`, { cwd: agent.cwd });
-                        fileDiff = stdout;
-                    }
-                    if (fileDiff) {
-                        const parsedFiles = await parseAndHighlightDiff(fileDiff, agent.cwd);
-                        for (const file of parsedFiles) {
-                            allFiles.push({ ...file, status: "ok" });
-                        }
-                    }
-                }
-                catch {
-                    // If diff fails for this file, add it with empty hunks
-                    allFiles.push({
-                        path: stats.path,
-                        isNew: stats.isNew,
-                        isDeleted: stats.isDeleted,
-                        additions: stats.additions,
-                        deletions: stats.deletions,
-                        hunks: [],
-                        status: "ok",
-                    });
-                }
-            }
-            this.emit({
-                type: "highlighted_diff_response",
-                payload: {
-                    agentId,
-                    files: allFiles,
-                    error: null,
-                    requestId,
-                },
-            });
-            this.sessionLogger.debug({ agentId, fileCount: allFiles.length }, `Highlighted diff for agent ${agentId} completed (${allFiles.length} files)`);
-        }
-        catch (error) {
-            this.sessionLogger.error({ err: error, agentId }, `Failed to get highlighted diff for agent ${agentId}`);
-            this.emit({
-                type: "highlighted_diff_response",
-                payload: {
-                    agentId,
-                    files: [],
-                    error: error.message,
-                    requestId,
-                },
-            });
-        }
-    }
     /**
      * Handle read-only file explorer requests scoped to an agent's cwd
      */
@@ -3825,7 +3694,7 @@ export class Session {
         if (!resolved.ok) {
             this.emit({
                 type: "wait_for_finish_response",
-                payload: { requestId, status: "error", final: null, error: resolved.error },
+                payload: { requestId, status: "error", final: null, error: resolved.error, lastMessage: null },
             });
             return;
         }
@@ -3841,6 +3710,7 @@ export class Session {
                         status: "error",
                         final: null,
                         error: `Agent not found: ${agentId}`,
+                        lastMessage: null,
                     },
                 });
                 return;
@@ -3853,7 +3723,7 @@ export class Session {
                     : "idle";
             this.emit({
                 type: "wait_for_finish_response",
-                payload: { requestId, status, final, error: null },
+                payload: { requestId, status, final, error: null, lastMessage: null },
             });
             return;
         }
@@ -3877,7 +3747,7 @@ export class Session {
                     : "idle";
             this.emit({
                 type: "wait_for_finish_response",
-                payload: { requestId, status, final, error: null },
+                payload: { requestId, status, final, error: null, lastMessage: result.lastMessage },
             });
         }
         catch (error) {
@@ -3894,6 +3764,7 @@ export class Session {
                         status: "error",
                         final,
                         error: message,
+                        lastMessage: null,
                     },
                 });
                 return;
@@ -3904,7 +3775,7 @@ export class Session {
             }
             this.emit({
                 type: "wait_for_finish_response",
-                payload: { requestId, status: "timeout", final, error: null },
+                payload: { requestId, status: "timeout", final, error: null, lastMessage: null },
             });
         }
         finally {
@@ -4390,7 +4261,7 @@ export class Session {
      * Clean up session resources
      */
     async cleanup() {
-        this.sessionLogger.info("Cleaning up");
+        this.sessionLogger.trace("Cleaning up");
         if (this.unsubscribeAgentEvents) {
             this.unsubscribeAgentEvents();
             this.unsubscribeAgentEvents = null;