@getpaseo/server 0.1.91 → 0.1.93

package/dist/server/server/agent/provider-session-import.d.ts

@@ -0,0 +1,10 @@
+import type { AgentClient, AgentPersistenceHandle, AgentProvider, AgentSessionConfig, ImportedProviderSession, ImportProviderSessionContext, ImportProviderSessionInput } from "./agent-sdk-types.js";
+export declare function importSessionFromPersistence(input: {
+    provider: AgentProvider;
+    request: ImportProviderSessionInput;
+    context: ImportProviderSessionContext;
+    resumeSession: AgentClient["resumeSession"];
+    config?: Partial<AgentSessionConfig>;
+    persistence?: AgentPersistenceHandle;
+}): Promise<ImportedProviderSession>;
+//# sourceMappingURL=provider-session-import.d.ts.map

package/dist/server/server/agent/provider-session-import.js

@@ -0,0 +1,49 @@
+export async function importSessionFromPersistence(input) {
+    const config = {
+        ...input.context.config,
+        ...input.config,
+        provider: input.provider,
+        cwd: input.request.cwd,
+    };
+    const storedConfig = {
+        ...input.context.storedConfig,
+        ...input.config,
+        provider: input.provider,
+        cwd: input.request.cwd,
+    };
+    const persistence = input.persistence ?? buildImportPersistenceHandle(input.provider, input.request, storedConfig);
+    const session = await input.resumeSession(persistence, config, input.context.launchContext);
+    const timeline = await collectImportedTimeline(session.streamHistory());
+    return {
+        session,
+        config: storedConfig,
+        persistence,
+        timeline,
+    };
+}
+function buildImportPersistenceHandle(provider, input, config) {
+    return {
+        provider,
+        sessionId: input.providerHandleId,
+        nativeHandle: input.providerHandleId,
+        metadata: {
+            ...config,
+            provider,
+            cwd: input.cwd,
+        },
+    };
+}
+async function collectImportedTimeline(events) {
+    const timeline = [];
+    for await (const event of events) {
+        if (event.type !== "timeline") {
+            continue;
+        }
+        timeline.push({
+            item: event.item,
+            ...(event.timestamp ? { timestamp: event.timestamp } : {}),
+        });
+    }
+    return timeline;
+}
+//# sourceMappingURL=provider-session-import.js.map

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

@@ -2,8 +2,14 @@ import { type ChildProcessWithoutNullStreams } from "node:child_process";
 import type { ReadableStream as NodeReadableStream, WritableStream as NodeWritableStream } from "node:stream/web";
 import { ClientSideConnection, type Client as ACPClient, type CreateTerminalRequest, type InitializeResponse, type KillTerminalRequest, type LoadSessionResponse, type NewSessionResponse, type ReadTextFileRequest, type RequestPermissionRequest, type RequestPermissionResponse, type ResumeSessionResponse, type SessionConfigOption, type SessionMode, type SessionModelState, type SessionNotification, type TerminalOutputRequest, type TerminalOutputResponse, type ToolCallContent, type ToolCallLocation, type ToolCallStatus, type ToolKind, type Usage, type WaitForTerminalExitRequest, type WriteTextFileRequest, type Stream as ACPStream } from "@agentclientprotocol/sdk";
 import type { Logger } from "pino";
-import { type AgentCapabilityFlags, type AgentClient, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentUsage, type ListModesOptions, type ListModelsOptions, type ListPersistedAgentsOptions, type PersistedAgentDescriptor } from "../agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentLaunchContext, type AgentMode, type AgentModelDefinition, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPersistenceHandle, type AgentPromptInput, type AgentRunOptions, type AgentRunResult, type AgentRuntimeInfo, type AgentSession, type AgentSessionConfig, type AgentSlashCommand, type AgentStreamEvent, type AgentUsage, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ListModesOptions, type ListModelsOptions } from "../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
+export declare function summarizeACPRequestError(error: unknown): {
+    message: string;
+    code?: string;
+    diagnostic?: string;
+};
+export declare const DEFAULT_ACP_CAPABILITIES: AgentCapabilityFlags;
 export declare function createLoggedNdJsonStream(output: NodeWritableStream, input: NodeReadableStream, options: {
     logger: Logger;
     provider: string;
@@ -147,13 +153,15 @@ export declare class ACPAgentClient 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(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
+    importSession(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<import("../agent-sdk-types.js").ImportedProviderSession>;
     isAvailable(): Promise<boolean>;
     protected spawnProcess(launchEnv?: Record<string, string>, options?: {
         initializeTimeoutMs?: number;
     }): Promise<SpawnedACPProcess>;
     protected buildProbeClient(): ACPClient;
     protected closeProbe(probe: SpawnedACPProcess): Promise<void>;
+    protected runACPRequest<T>(request: () => Promise<T>): Promise<T>;
     protected resolveLaunchCommand(): Promise<{
         command: string;
         args: string[];
@@ -257,6 +265,8 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     }): Promise<void>;
     killTerminal(params: KillTerminalRequest): Promise<Record<string, never>>;
     private spawnProcess;
+    private runACPRequest;
+    private acpMcpServers;
     private applySessionState;
     private transformConfigOptions;
     private transformModeId;

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/claude/models.js

@@ -15,6 +15,13 @@ const CLAUDE_OPUS_EXTENDED_THINKING_OPTIONS = [
     { id: "max", label: "Max" },
 ];
 const CLAUDE_MODELS = [
+    {
+        provider: "claude",
+        id: "claude-fable-5",
+        label: "Fable 5",
+        description: "Fable 5 · Most powerful model",
+        thinkingOptions: [...CLAUDE_OPUS_EXTENDED_THINKING_OPTIONS],
+    },
     {
         provider: "claude",
         id: "claude-opus-4-8[1m]",
@@ -170,6 +177,14 @@ export function normalizeClaudeRuntimeModelId(value) {
     if (CLAUDE_MODELS.some((model) => model.id === trimmed)) {
         return trimmed;
     }
+    // Fable uses a single-segment version (claude-fable-5), not the {major}-{minor}
+    // scheme of opus/sonnet/haiku, so match it separately. This maps dated runtime
+    // strings (e.g. claude-fable-5-20260301) back to the catalog ID. No [1m] variant:
+    // Fable 5 is natively 1M, so there is no 200K-default model to opt into 1M.
+    const fableMatch = trimmed.match(/(?:claude-)?fable[-_ ]+(\d+)/i);
+    if (fableMatch) {
+        return `claude-fable-${fableMatch[1]}`;
+    }
     // Match: claude-{family}-{major}-{minor}[1m]? possibly followed by a date suffix
     const runtimeMatch = trimmed.match(/(?:claude-)?(opus|sonnet|haiku)[-_ ]+(\d+)[-.](\d+)(\[1m\])?/i);
     if (!runtimeMatch) {

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";
@@ -94,6 +95,7 @@ function formatOutOfBandStatusMessage(text) {
 const CODEX_APP_SERVER_CAPABILITIES = {
     supportsStreaming: true,
     supportsSessionPersistence: true,
+    supportsSessionListing: true,
     supportsDynamicModes: false,
     supportsMcpServers: true,
     supportsReasoningStream: true,
@@ -431,6 +433,7 @@ async function listCodexCustomPrompts() {
             name: `prompts:${name}`,
             description,
             argumentHint,
+            kind: "command",
         };
     }));
     const commands = parsedCommands.filter((cmd) => cmd !== null);
@@ -482,6 +485,7 @@ export async function listCodexSkills(cwd, workspaceGitService) {
                     name,
                     description,
                     argumentHint: "",
+                    kind: "skill",
                 });
             }
         }
@@ -580,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)
@@ -3006,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)
@@ -3015,6 +3016,7 @@ export class CodexAppServerAgentSession {
                 name: "compact",
                 description: "Summarize conversation to prevent hitting the context limit",
                 argumentHint: "",
+                kind: "command",
             },
         ];
         if (this.goalsEnabled) {
@@ -3022,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));
@@ -4315,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);
@@ -4333,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();