@getpaseo/server 0.1.91-beta.2 → 0.1.92

package/dist/server/server/agent/providers/acp-agent.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { Readable, Writable } from "node:stream";
 import { ClientSideConnection, PROTOCOL_VERSION, } from "@agentclientprotocol/sdk";
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
+import { importSessionFromPersistence } from "../provider-session-import.js";
 import { checkProviderLaunchAvailable, createProviderEnvSpec, resolveProviderLaunch, } from "../provider-launch-config.js";
 import { renderPromptAttachmentAsText } from "../prompt-attachments.js";
 import { appendOrReplaceGrowingAssistantMessage, runProviderTurn } from "./provider-runner.js";
@@ -19,15 +20,29 @@ function isRecord(value) {
 function isACPError(value) {
     return isRecord(value) && typeof value.message === "string" && typeof value.code === "number";
 }
-function summarizeACPRequestError(error) {
+function extractACPErrorDataMessage(data) {
+    if (!isRecord(data)) {
+        return null;
+    }
+    for (const key of ["details", "errorMessage", "message", "detail", "title"]) {
+        const value = data[key];
+        if (typeof value === "string" && value.trim()) {
+            return value.trim();
+        }
+    }
+    return extractACPErrorDataMessage(data.error);
+}
+export function summarizeACPRequestError(error) {
     // Promise rejections are untyped, but the ACP SDK rejects JSON-RPC failures as response.error.
     if (isACPError(error)) {
         const code = String(error.code);
+        const detail = extractACPErrorDataMessage(error.data);
+        const message = detail && detail !== error.message ? `${error.message}: ${detail}` : error.message;
         const data = error.data === undefined ? "" : ` | data=${JSON.stringify(error.data)}`;
         return {
-            message: error.message,
+            message,
             code,
-            diagnostic: `${error.message} | code=${code}${data}`,
+            diagnostic: `${message} | code=${code}${data}`,
         };
     }
     if (error instanceof Error) {
@@ -35,6 +50,15 @@ function summarizeACPRequestError(error) {
     }
     return { message: String(error) };
 }
+function toACPRequestError(error) {
+    if (!isACPError(error)) {
+        return error instanceof Error ? error : new Error(String(error));
+    }
+    const summary = summarizeACPRequestError(error);
+    const next = new Error(summary.message);
+    next.name = "ACPRequestError";
+    return next;
+}
 function resolveTerminalCommand(command, args) {
     if (args && args.length > 0) {
         return { command, args };
@@ -45,7 +69,7 @@ function resolveTerminalCommand(command, args) {
     const shell = platformShell();
     return { command: shell.command, args: [...shell.flag, command] };
 }
-const DEFAULT_ACP_CAPABILITIES = {
+export const DEFAULT_ACP_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
     supportsDynamicModes: true,
@@ -318,10 +342,10 @@ export class ACPAgentClient {
         const { cwd } = options;
         const probe = await this.spawnProcess(PROBE_ENV);
         try {
-            const response = await probe.connection.newSession({
+            const response = await this.runACPRequest(() => probe.connection.newSession({
                 cwd,
                 mcpServers: [],
-            });
+            }));
             const transformed = this.transformSessionResponse(response);
             const models = deriveModelDefinitionsFromACP(this.provider, transformed.models, transformed.configOptions);
             return this.modelTransformer ? this.modelTransformer(models) : models;
@@ -334,10 +358,10 @@ export class ACPAgentClient {
         const { cwd } = options;
         const probe = await this.spawnProcess(PROBE_ENV);
         try {
-            const response = await probe.connection.newSession({
+            const response = await this.runACPRequest(() => probe.connection.newSession({
                 cwd,
                 mcpServers: [],
-            });
+            }));
             const transformed = this.transformSessionResponse(response);
             const modeInfo = deriveModesFromACP(this.defaultModes, transformed.modes, transformed.configOptions);
             return modeInfo.modes;
@@ -346,7 +370,7 @@ export class ACPAgentClient {
             await this.closeProbe(probe);
         }
     }
-    async listPersistedAgents(options) {
+    async listImportableSessions(options) {
         const probe = await this.spawnProcess(PROBE_ENV);
         try {
             if (!probe.initialize.agentCapabilities?.sessionCapabilities?.list) {
@@ -355,25 +379,15 @@ export class ACPAgentClient {
             const sessions = [];
             let cursor;
             for (;;) {
-                const page = await probe.connection.listSessions(cursor ? { cursor } : {});
+                const page = await this.runACPRequest(() => probe.connection.listSessions(cursor ? { cursor } : {}));
                 for (const session of page.sessions) {
                     sessions.push({
-                        provider: this.provider,
-                        sessionId: session.sessionId,
+                        providerHandleId: session.sessionId,
                         cwd: session.cwd,
                         title: session.title ?? null,
+                        firstPromptPreview: null,
+                        lastPromptPreview: null,
                         lastActivityAt: session.updatedAt ? new Date(session.updatedAt) : new Date(0),
-                        persistence: {
-                            provider: this.provider,
-                            sessionId: session.sessionId,
-                            nativeHandle: session.sessionId,
-                            metadata: {
-                                provider: this.provider,
-                                cwd: session.cwd,
-                                title: session.title ?? null,
-                            },
-                        },
-                        timeline: [],
                     });
                 }
                 cursor = page.nextCursor ?? null;
@@ -388,6 +402,14 @@ export class ACPAgentClient {
             await this.closeProbe(probe);
         }
     }
+    async importSession(input, context) {
+        return importSessionFromPersistence({
+            provider: this.provider,
+            request: input,
+            context,
+            resumeSession: this.resumeSession.bind(this),
+        });
+    }
     async isAvailable() {
         try {
             await this.resolveLaunchCommand();
@@ -430,7 +452,7 @@ export class ACPAgentClient {
             : null;
         let initialize;
         try {
-            initialize = await Promise.race([
+            initialize = await this.runACPRequest(() => Promise.race([
                 connection.initialize({
                     protocolVersion: PROTOCOL_VERSION,
                     clientCapabilities: ACP_CLIENT_CAPABILITIES,
@@ -438,7 +460,7 @@ export class ACPAgentClient {
                 }),
                 spawnErrorPromise,
                 ...(initializeTimeoutPromise ? [initializeTimeoutPromise] : []),
-            ]);
+            ]));
         }
         catch (error) {
             await terminateChildProcess(child, 2000);
@@ -481,6 +503,14 @@ export class ACPAgentClient {
             await terminateChildProcess(probe.child, 2000);
         }
     }
+    async runACPRequest(request) {
+        try {
+            return await request();
+        }
+        catch (error) {
+            throw toACPRequestError(error);
+        }
+    }
     async resolveLaunchCommand() {
         const prefix = await resolveProviderLaunch({
             commandConfig: this.runtimeSettings?.command,
@@ -575,10 +605,10 @@ export class ACPAgentSession {
         this.child = spawned.child;
         this.connection = spawned.connection;
         this.agentCapabilities = spawned.initialize.agentCapabilities ?? null;
-        const response = await this.connection.newSession({
+        const response = await this.runACPRequest(() => this.connection.newSession({
             cwd: this.config.cwd,
-            mcpServers: normalizeMcpServers(this.config.mcpServers),
-        });
+            mcpServers: this.acpMcpServers(),
+        }));
         this.sessionId = response.sessionId;
         this.bootstrapThreadEventPending = true;
         this.applySessionState(response);
@@ -598,21 +628,21 @@ export class ACPAgentSession {
         const sessionCapabilities = this.agentCapabilities?.sessionCapabilities;
         if (this.agentCapabilities?.loadSession) {
             this.replayingHistory = true;
-            const response = await this.connection.loadSession({
+            const response = await this.runACPRequest(() => this.connection.loadSession({
                 sessionId: handle.sessionId,
                 cwd: this.config.cwd,
-                mcpServers: normalizeMcpServers(this.config.mcpServers),
-            });
+                mcpServers: this.acpMcpServers(),
+            }));
             this.replayingHistory = false;
             this.historyPending = this.persistedHistory.length > 0;
             this.applySessionState(response);
         }
         else if (sessionCapabilities?.resume) {
-            const response = await this.connection.unstable_resumeSession({
+            const response = await this.runACPRequest(() => this.connection.unstable_resumeSession({
                 sessionId: handle.sessionId,
                 cwd: this.config.cwd,
-                mcpServers: normalizeMcpServers(this.config.mcpServers),
-            });
+                mcpServers: this.acpMcpServers(),
+            }));
             this.applySessionState(response);
         }
         else {
@@ -1282,13 +1312,24 @@ export class ACPAgentSession {
         });
         const stream = createLoggedNdJsonStream(Writable.toWeb(child.stdin), Readable.toWeb(child.stdout), { logger: this.logger, provider: this.provider });
         const connection = new ClientSideConnection(() => this, stream);
-        const initialize = await connection.initialize({
+        const initialize = await this.runACPRequest(() => connection.initialize({
             protocolVersion: PROTOCOL_VERSION,
             clientCapabilities: ACP_CLIENT_CAPABILITIES,
             clientInfo: { name: "Paseo", version: "dev" },
-        });
+        }));
         return { child, connection, initialize };
     }
+    async runACPRequest(request) {
+        try {
+            return await request();
+        }
+        catch (error) {
+            throw toACPRequestError(error);
+        }
+    }
+    acpMcpServers() {
+        return this.capabilities.supportsMcpServers ? normalizeMcpServers(this.config.mcpServers) : [];
+    }
     applySessionState(response) {
         const transformed = this.sessionResponseTransformer
             ? this.sessionResponseTransformer(response)
@@ -1400,6 +1441,7 @@ export class ACPAgentSession {
                     name: command.name,
                     description: command.description,
                     argumentHint: "",
+                    kind: "command",
                 }));
                 this.settleCommandsReady();
                 return [];

package/dist/server/server/agent/providers/claude/agent.d.ts

@@ -1,7 +1,7 @@
 import { type AgentDefinition, type McpServerConfig as ClaudeSdkMcpServerConfig, type SDKMessage } from "@anthropic-ai/claude-agent-sdk";
 import type { Logger } from "pino";
 import { type ClaudeQueryFactory } from "./query.js";
-import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMetadata, type AgentModelDefinition, type AgentPersistenceHandle, type AgentSession, type AgentSessionConfig, type AgentTimelineItem, type ListModelsOptions, type ListPersistedAgentsOptions, type McpServerConfig, type PersistedAgentDescriptor } from "../../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMetadata, type AgentModelDefinition, type AgentPersistenceHandle, type AgentSession, type AgentSessionConfig, type AgentTimelineItem, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModelsOptions, type McpServerConfig } from "../../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../../provider-launch-config.js";
 export declare function normalizeClaudeAskUserQuestionUpdatedInput(updatedInput: AgentMetadata | undefined, fallbackInput: AgentMetadata | undefined): AgentMetadata;
 interface EventIdentifiers {
@@ -40,7 +40,8 @@ export declare class ClaudeAgentClient implements AgentClient {
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
     listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
-    listPersistedAgents(options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
+    listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
+    importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;
     getDiagnostic(): Promise<{
         diagnostic: string;

package/dist/server/server/agent/providers/claude/agent.js

@@ -17,6 +17,7 @@ import { realClaudeRewindSdk, revertClaudeConversation, revertClaudeFiles } from
 import { normalizeProviderReplayTimestamp } from "../../provider-history-timestamps.js";
 import { claudeProjectDirSync } from "./project-dir.js";
 import { getAgentStreamEventTurnId, } from "../../agent-sdk-types.js";
+import { importSessionFromPersistence } from "../../provider-session-import.js";
 import { checkProviderLaunchAvailable, createProviderEnv, createProviderEnvSpec, resolveProviderLaunch, } from "../../provider-launch-config.js";
 import { withTimeout } from "../../../../utils/promise-timeout.js";
 import { execCommand } from "../../../../utils/spawn.js";
@@ -87,6 +88,7 @@ function isImageMimeType(value) {
 const CLAUDE_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
+    supportsSessionListing: true,
     supportsDynamicModes: true,
     supportsMcpServers: true,
     supportsReasoningStream: true,
@@ -974,7 +976,7 @@ export class ClaudeAgentClient {
             fastModeEnabled: claudeConfig.featureValues?.fast_mode === true,
         });
     }
-    async listPersistedAgents(options) {
+    async listImportableSessions(options) {
         const configDir = process.env.CLAUDE_CONFIG_DIR ?? path.join(os.homedir(), ".claude");
         const projectsRoot = path.join(configDir, "projects");
         if (!(await pathExists(projectsRoot))) {
@@ -984,9 +986,17 @@ export class ClaudeAgentClient {
         const candidates = await collectRecentClaudeSessions(projectsRoot, limit * 3);
         const parsed = await Promise.all(candidates.map((candidate) => parseClaudeSessionDescriptor(candidate.path, candidate.mtime)));
         return parsed
-            .filter((descriptor) => descriptor !== null)
+            .filter((session) => session !== null)
             .slice(0, limit);
     }
+    async importSession(input, context) {
+        return importSessionFromPersistence({
+            provider: "claude",
+            request: input,
+            context,
+            resumeSession: this.resumeSession.bind(this),
+        });
+    }
     async isAvailable() {
         const launch = await resolveProviderLaunch({
             commandConfig: this.runtimeSettings?.command,
@@ -1655,6 +1665,7 @@ class ClaudeAgentSession {
                     name: cmd.name,
                     description: cmd.description,
                     argumentHint: cmd.argumentHint,
+                    kind: "command",
                 });
             }
         }
@@ -3951,16 +3962,12 @@ function applyClaudeSessionEntryToAccumulator(entryRaw, acc) {
             if (!acc.title) {
                 acc.title = text;
             }
-            acc.timeline.push({ type: "user_message", text });
+            const preview = normalizeImportablePromptPreview(text);
+            acc.firstPromptPreview ?? (acc.firstPromptPreview = preview);
+            acc.lastPromptPreview = preview;
         }
         return;
     }
-    if (entry.type === "assistant" && entry.message) {
-        const text = extractClaudeUserText(entry.message);
-        if (text) {
-            acc.timeline.push({ type: "assistant_message", text });
-        }
-    }
 }
 async function parseClaudeSessionDescriptor(filePath, mtime) {
     let content;
@@ -3974,7 +3981,8 @@ async function parseClaudeSessionDescriptor(filePath, mtime) {
         sessionId: null,
         cwd: null,
         title: null,
-        timeline: [],
+        firstPromptPreview: null,
+        lastPromptPreview: null,
     };
     for (const rawLine of content.split(/\r?\n/)) {
         const line = rawLine.trim();
@@ -3992,29 +4000,25 @@ async function parseClaudeSessionDescriptor(filePath, mtime) {
             break;
         }
     }
-    const { sessionId, cwd, title, timeline } = acc;
+    const { sessionId, cwd, title } = acc;
     if (!sessionId || !cwd) {
         return null;
     }
-    const persistence = {
-        provider: "claude",
-        sessionId,
-        nativeHandle: sessionId,
-        metadata: {
-            provider: "claude",
-            cwd,
-        },
-    };
     return {
-        provider: "claude",
-        sessionId,
+        providerHandleId: sessionId,
         cwd,
         title: (title ?? "").trim() || `Claude session ${sessionId.slice(0, 8)}`,
+        firstPromptPreview: acc.firstPromptPreview,
+        lastPromptPreview: acc.lastPromptPreview,
         lastActivityAt: mtime,
-        persistence,
-        timeline,
     };
 }
+function normalizeImportablePromptPreview(text) {
+    const normalized = text.trim().replace(/\s+/g, " ");
+    if (!normalized)
+        return null;
+    return normalized.length > 160 ? normalized.slice(0, 160) : normalized;
+}
 function extractClaudeUserText(messageRaw) {
     const message = toObjectRecord(messageRaw);
     if (!message) {

package/dist/server/server/agent/providers/codex-app-server-agent.d.ts

@@ -1,4 +1,4 @@
-import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPersistenceHandle, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentPromptContentBlock, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentTimelineItem, type ToolCallTimelineItem, type AgentUsage, type ListModelsOptions, type ListPersistedAgentsOptions, type PersistedAgentDescriptor } from "../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentCreateSessionOptions, type AgentFeature, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPersistenceHandle, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentPromptContentBlock, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentTimelineItem, type ToolCallTimelineItem, type AgentUsage, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModelsOptions } from "../agent-sdk-types.js";
 import type { Logger } from "pino";
 import type { ChildProcessWithoutNullStreams } from "node:child_process";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
@@ -293,7 +293,8 @@ export declare class CodexAppServerAgentClient implements AgentClient {
         sessionId: string;
         metadata?: Record<string, unknown>;
     }, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
-    listPersistedAgents(options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
+    listImportableSessions(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
+    importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
     archiveNativeSession(handle: AgentPersistenceHandle): Promise<void>;
     isAvailable(): Promise<boolean>;

package/dist/server/server/agent/providers/codex-app-server-agent.js

@@ -1,4 +1,5 @@
 import { getAgentStreamEventTurnId, } from "../agent-sdk-types.js";
+import { importSessionFromPersistence } from "../provider-session-import.js";
 import { homedir } from "node:os";
 import { randomUUID } from "node:crypto";
 import * as fsSync from "node:fs";
@@ -34,6 +35,14 @@ const TURN_START_TIMEOUT_MS = 90 * 1000;
 const INTERRUPT_TIMEOUT_MS = 2000;
 const CODEX_PROVIDER = "codex";
 const CODEX_IMAGE_ATTACHMENT_DIR = "paseo-attachments";
+// Codex treats most app-server client names as the model-request originator.
+// This reserved Codex name is non-originating, so requests keep Codex's default
+// CLI identity instead of showing up as Paseo in provider usage logs.
+const CODEX_NON_ORIGINATING_APP_SERVER_CLIENT_INFO = {
+    name: "codex_app_server_daemon",
+    title: "Codex App Server Daemon",
+    version: "0.0.0",
+};
 const ASSISTANT_MESSAGE_BOUNDARY_MARKDOWN = "\n\n---\n\n";
 const CODEX_TOOL_THREAD_ITEM_TYPES = new Set([
     "commandExecution",
@@ -86,6 +95,7 @@ function formatOutOfBandStatusMessage(text) {
 const CODEX_APP_SERVER_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
+    supportsSessionListing: true,
     supportsDynamicModes: false,
     supportsMcpServers: true,
     supportsReasoningStream: true,
@@ -423,6 +433,7 @@ async function listCodexCustomPrompts() {
             name: `prompts:${name}`,
             description,
             argumentHint,
+            kind: "command",
         };
     }));
     const commands = parsedCommands.filter((cmd) => cmd !== null);
@@ -474,6 +485,7 @@ export async function listCodexSkills(cwd, workspaceGitService) {
                     name,
                     description,
                     argumentHint: "",
+                    kind: "skill",
                 });
             }
         }
@@ -572,10 +584,6 @@ function filterCodexThreadsByCwd(threads, cwd) {
     const matchesCwd = createPathEquivalenceMatcher(cwd);
     return threads.filter((thread) => typeof thread.cwd === "string" && matchesCwd(thread.cwd));
 }
-function buildCodexThreadListTimeline(thread) {
-    const preview = typeof thread.preview === "string" ? thread.preview.trim() : "";
-    return preview ? [{ type: "user_message", text: preview }] : [];
-}
 export function toAgentUsage(tokenUsage) {
     const usage = toObjectRecord(tokenUsage);
     if (!usage)
@@ -2093,11 +2101,7 @@ export function buildCodexAppServerEnv(runtimeSettings, launchEnv) {
 }
 function buildCodexAppServerInitializeParams() {
     return {
-        clientInfo: {
-            name: "paseo",
-            title: "Paseo",
-            version: "0.0.0",
-        },
+        clientInfo: CODEX_NON_ORIGINATING_APP_SERVER_CLIENT_INFO,
         capabilities: {
             experimentalApi: true,
         },
@@ -3002,6 +3006,7 @@ export class CodexAppServerAgentSession {
             name: skill.name,
             description: skill.description,
             argumentHint: "",
+            kind: "skill",
         }));
         const fallbackSkills = appServerSkills.length === 0
             ? await listCodexSkills(this.config.cwd, this.deps.workspaceGitService)
@@ -3011,6 +3016,7 @@ export class CodexAppServerAgentSession {
                 name: "compact",
                 description: "Summarize conversation to prevent hitting the context limit",
                 argumentHint: "",
+                kind: "command",
             },
         ];
         if (this.goalsEnabled) {
@@ -3018,6 +3024,7 @@ export class CodexAppServerAgentSession {
                 name: "goal",
                 description: "Set, pause, resume, or clear the agent's goal",
                 argumentHint: "[<objective>|pause|resume|clear]",
+                kind: "command",
             });
         }
         return [...builtin, ...appServerSkills, ...fallbackSkills, ...prompts].sort((a, b) => a.name.localeCompare(b.name));
@@ -4311,7 +4318,7 @@ export class CodexAppServerAgentClient {
         await session.connect();
         return session;
     }
-    async listPersistedAgents(options) {
+    async listImportableSessions(options) {
         const child = await this.spawnAppServer();
         const client = this.deps._createCodexClient?.(child, this.logger, () => ({})) ??
             new CodexAppServerClient(child, this.logger);
@@ -4329,39 +4336,35 @@ export class CodexAppServerAgentClient {
             }));
             const allThreads = Array.isArray(response?.data) ? response.data.filter(isRecord) : [];
             const threads = filterCodexThreadsByCwd(allThreads, options?.cwd);
-            const descriptors = threads.slice(0, limit).map((thread) => {
+            return threads.slice(0, limit).map((thread) => {
                 const threadId = typeof thread.id === "string" ? thread.id : "";
                 const cwd = typeof thread.cwd === "string" ? thread.cwd : process.cwd();
                 const preview = typeof thread.preview === "string" ? thread.preview : null;
                 const title = typeof thread.name === "string" && thread.name.trim() ? thread.name : preview;
                 return {
-                    provider: CODEX_PROVIDER,
-                    sessionId: threadId,
+                    providerHandleId: threadId,
                     cwd,
                     title,
+                    firstPromptPreview: preview,
+                    lastPromptPreview: preview,
                     lastActivityAt: new Date(((typeof thread.updatedAt === "number" ? thread.updatedAt : undefined) ??
                         (typeof thread.createdAt === "number" ? thread.createdAt : undefined) ??
                         0) * 1000),
-                    persistence: {
-                        provider: CODEX_PROVIDER,
-                        sessionId: threadId,
-                        nativeHandle: threadId,
-                        metadata: {
-                            provider: CODEX_PROVIDER,
-                            cwd,
-                            title,
-                            threadId,
-                        },
-                    },
-                    timeline: buildCodexThreadListTimeline(thread),
                 };
             });
-            return descriptors;
         }
         finally {
             await client.dispose();
         }
     }
+    async importSession(input, context) {
+        return importSessionFromPersistence({
+            provider: CODEX_PROVIDER,
+            request: input,
+            context,
+            resumeSession: this.resumeSession.bind(this),
+        });
+    }
     async listModels(_options) {
         // Codex model/list is global to the app server in this flow; cwd/force are intentionally ignored.
         const child = await this.spawnAppServer();

package/dist/server/server/agent/providers/cursor-acp-agent.d.ts

@@ -7,6 +7,7 @@ interface CursorACPAgentClientOptions {
     env?: Record<string, string>;
     providerId?: string;
     label?: string;
+    providerParams?: unknown;
 }
 export declare class CursorACPAgentClient extends GenericACPAgentClient {
     private readonly cursorCommand;

package/dist/server/server/agent/providers/cursor-acp-agent.js

@@ -12,6 +12,7 @@ export class CursorACPAgentClient extends GenericACPAgentClient {
             env: options.env,
             providerId: options.providerId,
             label: options.label,
+            providerParams: options.providerParams,
             // cursor-agent publishes slash commands asynchronously via available_commands_update.
             waitForInitialCommands: true,
             initialCommandsWaitTimeoutMs: CURSOR_INITIAL_COMMANDS_WAIT_TIMEOUT_MS,

package/dist/server/server/agent/providers/generic-acp-agent.d.ts

@@ -1,11 +1,20 @@
 import type { Logger } from "pino";
+import { z } from "zod";
 import { ACPAgentClient } from "./acp-agent.js";
+export declare const GenericACPProviderParamsSchema: z.ZodObject<{
+    supportsMcpServers: z.ZodOptional<z.ZodBoolean>;
+}, "passthrough", z.ZodTypeAny, z.objectOutputType<{
+    supportsMcpServers: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">, z.objectInputType<{
+    supportsMcpServers: z.ZodOptional<z.ZodBoolean>;
+}, z.ZodTypeAny, "passthrough">>;
 interface GenericACPAgentClientOptions {
     logger: Logger;
     command: [string, ...string[]];
     env?: Record<string, string>;
     providerId?: string;
     label?: string;
+    providerParams?: unknown;
     waitForInitialCommands?: boolean;
     initialCommandsWaitTimeoutMs?: number;
 }

package/dist/server/server/agent/providers/generic-acp-agent.js

@@ -1,9 +1,15 @@
 import { homedir } from "node:os";
+import { z } from "zod";
 import { checkProviderLaunchAvailable, resolveProviderLaunch } from "../provider-launch-config.js";
-import { ACPAgentClient, deriveModelDefinitionsFromACP, deriveModesFromACP, } from "./acp-agent.js";
+import { ACPAgentClient, DEFAULT_ACP_CAPABILITIES, deriveModelDefinitionsFromACP, deriveModesFromACP, } from "./acp-agent.js";
 import { formatDiagnosticStatus, formatProviderDiagnostic, formatProviderDiagnosticError, buildBinaryDiagnosticRows, toDiagnosticErrorMessage, } from "./diagnostic-utils.js";
 const ACP_DIAGNOSTIC_INITIALIZE_TIMEOUT_MS = 8000;
 const ACP_DIAGNOSTIC_SESSION_TIMEOUT_MS = 8000;
+export const GenericACPProviderParamsSchema = z
+    .object({
+    supportsMcpServers: z.boolean().optional(),
+})
+    .passthrough();
 export class GenericACPAgentClient extends ACPAgentClient {
     constructor(options) {
         super({
@@ -13,6 +19,7 @@ export class GenericACPAgentClient extends ACPAgentClient {
                 env: options.env,
             },
             defaultCommand: options.command,
+            capabilities: buildGenericACPCapabilities(options),
             waitForInitialCommands: options.waitForInitialCommands,
             initialCommandsWaitTimeoutMs: options.initialCommandsWaitTimeoutMs,
         });
@@ -128,6 +135,16 @@ export class GenericACPAgentClient extends ACPAgentClient {
         }
     }
 }
+function buildGenericACPCapabilities(options) {
+    const params = parseGenericACPProviderParams(options.providerParams);
+    return {
+        ...DEFAULT_ACP_CAPABILITIES,
+        supportsMcpServers: params.supportsMcpServers ?? DEFAULT_ACP_CAPABILITIES.supportsMcpServers,
+    };
+}
+function parseGenericACPProviderParams(params) {
+    return GenericACPProviderParamsSchema.parse(params ?? {});
+}
 function formatProviderName(label, providerId) {
     if (label) {
         return `${label} (ACP)`;

package/dist/server/server/agent/providers/mock-load-test-agent.d.ts

@@ -1,5 +1,5 @@
 import type { Logger } from "pino";
-import type { AgentCapabilityFlags, AgentClient, AgentFeature, AgentLaunchContext, AgentMode, AgentModelDefinition, AgentPersistenceHandle, AgentPermissionRequest, AgentPermissionResponse, AgentPermissionResult, AgentPromptInput, AgentProvider, AgentRunOptions, AgentRunResult, AgentRuntimeInfo, AgentSession, AgentSessionConfig, AgentStreamEvent, ListModesOptions, ListModelsOptions, ListPersistedAgentsOptions, PersistedAgentDescriptor } from "../agent-sdk-types.js";
+import type { AgentCapabilityFlags, AgentClient, AgentFeature, AgentLaunchContext, AgentMode, AgentModelDefinition, AgentPersistenceHandle, AgentPermissionRequest, AgentPermissionResponse, AgentPermissionResult, AgentPromptInput, AgentProvider, AgentRunOptions, AgentRunResult, AgentRuntimeInfo, AgentSession, AgentSessionConfig, AgentStreamEvent, ImportableProviderSession, ImportProviderSessionContext, ImportProviderSessionInput, ListModesOptions, ListModelsOptions } from "../agent-sdk-types.js";
 export declare const MOCK_LOAD_TEST_PROVIDER_ID = "mock";
 export declare const MOCK_LOAD_TEST_DEFAULT_MODEL_ID = "five-minute-stream";
 export declare class MockLoadTestAgentClient implements AgentClient {
@@ -11,7 +11,8 @@ export declare class MockLoadTestAgentClient implements AgentClient {
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, _launchContext?: AgentLaunchContext): Promise<AgentSession>;
     listModels(_options: ListModelsOptions): Promise<AgentModelDefinition[]>;
     listModes(_options: ListModesOptions): Promise<AgentMode[]>;
-    listPersistedAgents(_options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
+    listImportableSessions(): Promise<ImportableProviderSession[]>;
+    importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;
     getDiagnostic(): Promise<{
         diagnostic: string;