@getpaseo/server 0.1.14 → 0.1.16

package/dist/server/server/session.js

@@ -17,7 +17,7 @@ import { buildConfigOverrides, buildSessionConfig, extractTimestamps } from './p
 import { experimental_createMCPClient } from 'ai';
 import { buildProviderRegistry } from './agent/provider-registry.js';
 import { scheduleAgentMetadataGeneration } from './agent/agent-metadata-generator.js';
-import { toAgentPayload } from './agent/agent-projections.js';
+import { resolveEffectiveThinkingOptionId, toAgentPayload } from './agent/agent-projections.js';
 import { appendTimelineItemIfAgentKnown, emitLiveTimelineItemIfAgentKnown, } from './agent/timeline-append.js';
 import { projectTimelineRows } from './agent/timeline-projection.js';
 import { DEFAULT_STRUCTURED_GENERATION_PROVIDERS, StructuredAgentFallbackError, StructuredAgentResponseError, generateStructuredAgentResponseWithFallback, } from './agent/agent-response-loop.js';
@@ -32,6 +32,7 @@ import { getProjectIcon } from '../utils/project-icon.js';
 import { expandTilde } from '../utils/path.js';
 import { searchHomeDirectories, searchWorkspaceEntries } from '../utils/directory-suggestions.js';
 import { ensureLocalSpeechModels, getLocalSpeechModelDir, listLocalSpeechModels, } from './speech/providers/local/models.js';
+import { resolveClientMessageId } from './client-message-id.js';
 const execAsync = promisify(exec);
 const READ_ONLY_GIT_ENV = {
     ...process.env,
@@ -516,12 +517,33 @@ export class Session {
         const updatedAt = new Date(record.lastActivityAt ?? record.updatedAt);
         const lastUserMessageAt = record.lastUserMessageAt ? new Date(record.lastUserMessageAt) : null;
         const provider = coerceAgentProvider(this.sessionLogger, record.provider, record.id);
+        const runtimeInfo = record.runtimeInfo
+            ? {
+                provider: coerceAgentProvider(this.sessionLogger, record.runtimeInfo.provider, record.id),
+                sessionId: record.runtimeInfo.sessionId,
+                ...(Object.prototype.hasOwnProperty.call(record.runtimeInfo, 'model')
+                    ? { model: record.runtimeInfo.model ?? null }
+                    : {}),
+                ...(Object.prototype.hasOwnProperty.call(record.runtimeInfo, 'thinkingOptionId')
+                    ? { thinkingOptionId: record.runtimeInfo.thinkingOptionId ?? null }
+                    : {}),
+                ...(Object.prototype.hasOwnProperty.call(record.runtimeInfo, 'modeId')
+                    ? { modeId: record.runtimeInfo.modeId ?? null }
+                    : {}),
+                ...(record.runtimeInfo.extra ? { extra: record.runtimeInfo.extra } : {}),
+            }
+            : undefined;
         return {
             id: record.id,
             provider,
             cwd: record.cwd,
             model: record.config?.model ?? null,
             thinkingOptionId: record.config?.thinkingOptionId ?? null,
+            effectiveThinkingOptionId: resolveEffectiveThinkingOptionId({
+                runtimeInfo,
+                configuredThinkingOptionId: record.config?.thinkingOptionId ?? null,
+            }),
+            ...(runtimeInfo ? { runtimeInfo } : {}),
             createdAt: createdAt.toISOString(),
             updatedAt: updatedAt.toISOString(),
             lastUserMessageAt: lastUserMessageAt ? lastUserMessageAt.toISOString() : null,
@@ -592,6 +614,19 @@ export class Session {
         if (!includeArchived && agent.archivedAt) {
             return false;
         }
+        if (filter?.thinkingOptionId !== undefined) {
+            const expectedThinkingOptionId = resolveEffectiveThinkingOptionId({
+                configuredThinkingOptionId: filter.thinkingOptionId ?? null,
+            });
+            const resolvedThinkingOptionId = agent.effectiveThinkingOptionId ??
+                resolveEffectiveThinkingOptionId({
+                    runtimeInfo: agent.runtimeInfo,
+                    configuredThinkingOptionId: agent.thinkingOptionId ?? null,
+                });
+            if (resolvedThinkingOptionId !== expectedThinkingOptionId) {
+                return false;
+            }
+        }
         if (filter?.statuses && filter.statuses.length > 0) {
             const statuses = new Set(filter.statuses);
             if (!statuses.has(agent.status)) {
@@ -1093,6 +1128,9 @@ export class Session {
     }
     async handleArchiveAgentRequest(agentId, requestId) {
         this.sessionLogger.info({ agentId }, `Archiving agent ${agentId}`);
+        if (this.agentManager.getAgent(agentId)) {
+            await this.interruptAgentIfRunning(agentId);
+        }
         const archivedAt = new Date().toISOString();
         const existing = await this.agentStorage.get(agentId);
         let archivedRecord = existing;
@@ -1102,7 +1140,6 @@ export class Session {
                 throw new Error(`Agent not found: ${agentId}`);
             }
             await this.agentStorage.applySnapshot(liveAgent, {
-                title: liveAgent.config.title ?? null,
                 internal: liveAgent.internal,
             });
             archivedRecord = await this.agentStorage.get(agentId);
@@ -1130,6 +1167,10 @@ export class Session {
             requestId,
         });
     }
+    async getArchivedAt(agentId) {
+        const record = await this.agentStorage.get(agentId);
+        return record?.archivedAt ?? null;
+    }
     async handleUpdateAgentRequest(agentId, name, labels, requestId) {
         this.sessionLogger.info({
             agentId,
@@ -1608,6 +1649,11 @@ export class Session {
             this.handleAgentRunError(agentId, error, 'Failed to initialize agent before sending prompt');
             return;
         }
+        const archivedAt = await this.getArchivedAt(agentId);
+        if (archivedAt) {
+            this.handleAgentRunError(agentId, new Error(`Agent ${agentId} is archived`), 'Refusing to send prompt to archived agent');
+            return;
+        }
         try {
             await this.interruptAgentIfRunning(agentId);
         }
@@ -1631,7 +1677,7 @@ export class Session {
      * Handle create agent request
      */
     async handleCreateAgentRequest(msg) {
-        const { config, worktreeName, requestId, initialPrompt, outputSchema, git, images, labels } = msg;
+        const { config, worktreeName, requestId, initialPrompt, clientMessageId, 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);
@@ -1649,7 +1695,7 @@ export class Session {
                     logger: this.sessionLogger,
                 });
                 try {
-                    await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, uuidv4(), images, outputSchema ? { outputSchema } : undefined);
+                    await this.handleSendAgentMessage(snapshot.id, trimmedPrompt, resolveClientMessageId(clientMessageId), images, outputSchema ? { outputSchema } : undefined);
                 }
                 catch (promptError) {
                     this.sessionLogger.error({ err: promptError, agentId: snapshot.id }, `Failed to run initial prompt for agent ${snapshot.id}`);
@@ -3767,6 +3813,18 @@ export class Session {
                 return entry.agent.title?.toLocaleLowerCase() ?? '';
         }
     }
+    getFetchAgentsSortValueFromAgent(agent, key) {
+        switch (key) {
+            case 'status_priority':
+                return this.getStatusPriority(agent);
+            case 'created_at':
+                return Date.parse(agent.createdAt);
+            case 'updated_at':
+                return Date.parse(agent.updatedAt);
+            case 'title':
+                return agent.title?.toLocaleLowerCase() ?? '';
+        }
+    }
     compareSortValues(left, right) {
         if (left === right) {
             return 0;
@@ -3782,17 +3840,17 @@ export class Session {
         }
         return String(left).localeCompare(String(right));
     }
-    compareFetchAgentsEntries(left, right, sort) {
+    compareFetchAgentsAgents(left, right, sort) {
         for (const spec of sort) {
-            const leftValue = this.getFetchAgentsSortValue(left, spec.key);
-            const rightValue = this.getFetchAgentsSortValue(right, spec.key);
+            const leftValue = this.getFetchAgentsSortValueFromAgent(left, spec.key);
+            const rightValue = this.getFetchAgentsSortValueFromAgent(right, spec.key);
             const base = this.compareSortValues(leftValue, rightValue);
             if (base === 0) {
                 continue;
             }
             return spec.direction === 'asc' ? base : -base;
         }
-        return left.agent.id.localeCompare(right.agent.id);
+        return left.id.localeCompare(right.id);
     }
     encodeFetchAgentsCursor(entry, sort) {
         const values = {};
@@ -3852,9 +3910,9 @@ export class Session {
             id: payload.id,
         };
     }
-    compareEntryWithCursor(entry, cursor, sort) {
+    compareAgentWithCursor(agent, cursor, sort) {
         for (const spec of sort) {
-            const leftValue = this.getFetchAgentsSortValue(entry, spec.key);
+            const leftValue = this.getFetchAgentsSortValueFromAgent(agent, spec.key);
             const rightValue = cursor.values[spec.key] !== undefined ? (cursor.values[spec.key] ?? null) : null;
             const base = this.compareSortValues(leftValue, rightValue);
             if (base === 0) {
@@ -3862,7 +3920,7 @@ export class Session {
             }
             return spec.direction === 'asc' ? base : -base;
         }
-        return entry.agent.id.localeCompare(cursor.id);
+        return agent.id.localeCompare(cursor.id);
     }
     async listFetchAgentsEntries(request) {
         const filter = request.filter;
@@ -3880,24 +3938,38 @@ export class Session {
             placementByCwd.set(cwd, placementPromise);
             return placementPromise;
         };
-        let entries = await Promise.all(agents.map(async (agent) => ({
-            agent,
-            project: await getPlacement(agent.cwd),
-        })));
-        entries = entries.filter((entry) => this.matchesAgentFilter({
-            agent: entry.agent,
-            project: entry.project,
-            filter,
-        }));
-        entries.sort((left, right) => this.compareFetchAgentsEntries(left, right, sort));
+        let candidates = [...agents];
+        candidates.sort((left, right) => this.compareFetchAgentsAgents(left, right, sort));
         const cursorToken = request.page?.cursor;
         if (cursorToken) {
             const cursor = this.decodeFetchAgentsCursor(cursorToken, sort);
-            entries = entries.filter((entry) => this.compareEntryWithCursor(entry, cursor, sort) > 0);
+            candidates = candidates.filter((agent) => this.compareAgentWithCursor(agent, cursor, sort) > 0);
+        }
+        const limit = request.page?.limit ?? 200;
+        const matchedEntries = [];
+        const batchSize = 25;
+        for (let start = 0; start < candidates.length && matchedEntries.length <= limit; start += batchSize) {
+            const batch = candidates.slice(start, start + batchSize);
+            const batchEntries = await Promise.all(batch.map(async (agent) => ({
+                agent,
+                project: await getPlacement(agent.cwd),
+            })));
+            for (const entry of batchEntries) {
+                if (!this.matchesAgentFilter({
+                    agent: entry.agent,
+                    project: entry.project,
+                    filter,
+                })) {
+                    continue;
+                }
+                matchedEntries.push(entry);
+                if (matchedEntries.length > limit) {
+                    break;
+                }
+            }
         }
-        const limit = request.page?.limit ?? entries.length;
-        const pagedEntries = entries.slice(0, limit);
-        const hasMore = entries.length > limit;
+        const pagedEntries = matchedEntries.slice(0, limit);
+        const hasMore = matchedEntries.length > limit;
         const nextCursor = hasMore && pagedEntries.length > 0
             ? this.encodeFetchAgentsCursor(pagedEntries[pagedEntries.length - 1], sort)
             : null;
@@ -3969,7 +4041,7 @@ export class Session {
         if (!resolved.ok) {
             this.emit({
                 type: 'fetch_agent_response',
-                payload: { requestId, agent: null, error: resolved.error },
+                payload: { requestId, agent: null, project: null, error: resolved.error },
             });
             return;
         }
@@ -3977,13 +4049,19 @@ export class Session {
         if (!agent) {
             this.emit({
                 type: 'fetch_agent_response',
-                payload: { requestId, agent: null, error: `Agent not found: ${resolved.agentId}` },
+                payload: {
+                    requestId,
+                    agent: null,
+                    project: null,
+                    error: `Agent not found: ${resolved.agentId}`,
+                },
             });
             return;
         }
+        const project = await this.buildProjectPlacement(agent.cwd);
         this.emit({
             type: 'fetch_agent_response',
-            payload: { requestId, agent, error: null },
+            payload: { requestId, agent, project, error: null },
         });
     }
     async handleFetchAgentTimelineRequest(msg) {
@@ -4069,6 +4147,19 @@ export class Session {
         }
         try {
             const agentId = resolved.agentId;
+            const archivedAt = await this.getArchivedAt(agentId);
+            if (archivedAt) {
+                this.emit({
+                    type: 'send_agent_message_response',
+                    payload: {
+                        requestId: msg.requestId,
+                        agentId,
+                        accepted: false,
+                        error: `Agent ${agentId} is archived`,
+                    },
+                });
+                return;
+            }
             await this.ensureAgentLoaded(agentId);
             await this.interruptAgentIfRunning(agentId);
             try {
@@ -4193,14 +4284,14 @@ export class Session {
             abortController.abort('timeout');
         }, effectiveTimeoutMs);
         try {
-            const result = await this.agentManager.waitForAgentEvent(agentId, {
+            let result = await this.agentManager.waitForAgentEvent(agentId, {
                 signal: abortController.signal,
             });
-            const final = await this.getAgentPayloadById(agentId);
+            let final = await this.getAgentPayloadById(agentId);
             if (!final) {
                 throw new Error(`Agent ${agentId} disappeared while waiting`);
             }
-            const status = result.permission ? 'permission' : result.status === 'error' ? 'error' : 'idle';
+            let status = result.permission ? 'permission' : result.status === 'error' ? 'error' : 'idle';
             this.emit({
                 type: 'wait_for_finish_response',
                 payload: { requestId, status, final, error: null, lastMessage: result.lastMessage },