@getpaseo/server 0.1.91 → 0.1.93

package/dist/server/server/agent/agent-manager.d.ts

@@ -1,7 +1,7 @@
 import { AGENT_LIFECYCLE_STATUSES, type AgentLifecycleStatus } from "@getpaseo/protocol/agent-lifecycle";
 import type { Logger } from "pino";
 import type { TerminalManager } from "../../terminal/terminal-manager.js";
-import { type AgentCapabilityFlags, type AgentClient, type AgentFeature, type AgentSlashCommand, type AgentMode, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentPersistenceHandle, type AgentPromptInput, type AgentProvider, type AgentRunOptions, type AgentRunResult, type AgentSession, type AgentSessionConfig, type AgentStreamEvent, type AgentTimelineItem, type AgentUsage, type AgentRuntimeInfo, type ListPersistedAgentsOptions, type PersistedAgentDescriptor } from "./agent-sdk-types.js";
+import { type AgentCapabilityFlags, type AgentClient, type AgentFeature, type AgentSlashCommand, type AgentMode, type AgentPermissionRequest, type AgentPermissionResponse, type AgentPermissionResult, type AgentPersistenceHandle, type AgentPromptInput, type AgentProvider, type AgentRunOptions, type AgentRunResult, type AgentSession, type AgentSessionConfig, type AgentStreamEvent, type AgentTimelineItem, type AgentUsage, type AgentRuntimeInfo, type ImportableProviderSession, type ListImportableSessionsOptions } from "./agent-sdk-types.js";
 import type { StoredAgentRecord, AgentStorage } from "./agent-storage.js";
 import type { AgentTimelineFetchOptions, AgentTimelineFetchResult, AgentTimelineRow, AgentTimelineStore } from "./agent-timeline-store-types.js";
 import { type ForegroundTurnWaiter } from "./foreground-run-state.js";
@@ -28,13 +28,16 @@ interface HydrateTimelineOptions {
     force?: boolean;
     broadcast?: boolean;
 }
-export type ImportablePersistedAgentQueryOptions = ListPersistedAgentsOptions & {
+export type ImportablePersistedAgentQueryOptions = ListImportableSessionsOptions & {
     /**
      * When set, only providers in this set are scanned, in addition to the
      * built-in importable allowlist + enabled + non-derived rules.
      */
     providerFilter?: Set<string>;
 };
+export interface ManagedImportableProviderSession extends ImportableProviderSession {
+    provider: AgentProvider;
+}
 export type AgentAttentionCallback = (params: {
     agentId: string;
     provider: AgentProvider;
@@ -198,9 +201,8 @@ export declare class AgentManager {
     hasInFlightRun(agentId: string): boolean;
     subscribe(callback: AgentSubscriber, options?: SubscribeOptions): () => void;
     listAgents(): ManagedAgent[];
-    listImportablePersistedAgents(options?: ImportablePersistedAgentQueryOptions): Promise<PersistedAgentDescriptor[]>;
+    listImportableSessions(options?: ImportablePersistedAgentQueryOptions): Promise<ManagedImportableProviderSession[]>;
     private isProviderImportable;
-    findPersistedAgent(provider: AgentProvider, sessionId: string, options?: Pick<ListPersistedAgentsOptions, "cwd">): Promise<PersistedAgentDescriptor | null>;
     listProviderAvailability(): Promise<ProviderAvailability[]>;
     listDraftCommands(config: AgentSessionConfig): Promise<AgentSlashCommand[]>;
     listDraftFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
@@ -223,6 +225,12 @@ export declare class AgentManager {
         lastUserMessageAt?: Date | null;
         labels?: Record<string, string>;
     }): Promise<ManagedAgent>;
+    importProviderSession(input: {
+        provider: AgentProvider;
+        providerHandleId: string;
+        cwd: string;
+        labels?: Record<string, string>;
+    }): Promise<ManagedAgent>;
     reloadAgentSession(agentId: string, overrides?: Partial<AgentSessionConfig>, options?: {
         rehydrateFromDisk?: boolean;
     }): Promise<ManagedAgent>;

package/dist/server/server/agent/agent-manager.js

@@ -13,6 +13,7 @@ import { getAgentProviderDefinition } from "@getpaseo/protocol/provider-manifest
 import { invokeRewindCapability } from "./rewind/rewind.js";
 import { isSystemInjectedEnvelope } from "./agent-prompt.js";
 import { stripInternalPaseoMcpServer, withRuntimePaseoMcpServer } from "./runtime-mcp-config.js";
+import { resolveCreateAgentTitles } from "./create-agent-title.js";
 const RELOAD_SESSION_CLOSE_TIMEOUT_MS = 3000;
 const INTERRUPT_SESSION_TIMEOUT_MS = 2000;
 const STORED_AGENT_CAPABILITIES = {
@@ -122,6 +123,44 @@ function buildExplicitTimelineSeedForRegister(now, options) {
         timestamp: (options?.updatedAt ?? options?.createdAt ?? now).toISOString(),
     };
 }
+function buildImportedTimelineRows(entries) {
+    const rows = [];
+    for (const entry of entries) {
+        if (entry.item.type === "user_message" && isSystemInjectedEnvelope(entry.item.text)) {
+            continue;
+        }
+        rows.push({
+            seq: rows.length + 1,
+            timestamp: entry.timestamp ?? new Date().toISOString(),
+            item: entry.item,
+        });
+    }
+    return rows;
+}
+function resolveImportedAgentTitle(config, timelineRows) {
+    const initialPrompt = getFirstUserMessageTextFromRows(timelineRows);
+    if (!initialPrompt) {
+        return null;
+    }
+    const { explicitTitle, provisionalTitle } = resolveCreateAgentTitles({
+        configTitle: config.title,
+        initialPrompt,
+    });
+    return explicitTitle ?? provisionalTitle ?? null;
+}
+function getFirstUserMessageTextFromRows(rows) {
+    for (const row of rows) {
+        const item = row.item;
+        if (item.type !== "user_message") {
+            continue;
+        }
+        const text = item.text.trim();
+        if (text) {
+            return text;
+        }
+    }
+    return null;
+}
 export class AgentManager {
     constructor(options) {
         this.clients = new Map();
@@ -279,24 +318,25 @@ export class AgentManager {
             .filter((agent) => !agent.internal)
             .map((agent) => Object.assign({}, agent));
     }
-    async listImportablePersistedAgents(options) {
-        const providerEntries = Array.from(this.clients.entries()).filter(([provider, client]) => !!client.listPersistedAgents &&
+    async listImportableSessions(options) {
+        const providerEntries = Array.from(this.clients.entries()).filter(([provider, client]) => client.capabilities.supportsSessionListing &&
+            !!client.listImportableSessions &&
             this.isProviderImportable(provider, options?.providerFilter));
-        const descriptorLists = await Promise.all(providerEntries.map(async ([provider, client]) => {
+        const sessionLists = await Promise.all(providerEntries.map(async ([provider, client]) => {
             try {
-                return await client.listPersistedAgents({
+                return (await client.listImportableSessions({
                     limit: options?.limit,
                     cwd: options?.cwd,
-                });
+                })).map((session) => Object.assign(session, { provider }));
             }
             catch (error) {
-                this.logger.warn({ err: error, provider }, "Failed to list persisted agents for provider");
+                this.logger.warn({ err: error, provider }, "Failed to list importable sessions for provider");
                 return [];
             }
         }));
-        const descriptors = descriptorLists.flat();
+        const sessions = sessionLists.flat();
         const limit = options?.limit ?? 20;
-        return descriptors
+        return sessions
             .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
             .slice(0, limit);
     }
@@ -309,16 +349,6 @@ export class AgentManager {
         }
         return true;
     }
-    async findPersistedAgent(provider, sessionId, options) {
-        const client = this.requireClient(provider);
-        if (!client.listPersistedAgents) {
-            return null;
-        }
-        const descriptors = await client.listPersistedAgents({ limit: 200, cwd: options?.cwd });
-        return (descriptors.find((descriptor) => {
-            return (descriptor.sessionId === sessionId || descriptor.persistence.nativeHandle === sessionId);
-        }) ?? null);
-    }
     async listProviderAvailability() {
         const checks = Array.from(this.clients.keys()).map(async (provider) => {
             const client = this.clients.get(provider);
@@ -458,6 +488,35 @@ export class AgentManager {
         const session = await client.resumeSession(handle, launchConfig, launchContext);
         return this.registerSession(session, storedConfig, resolvedAgentId, options);
     }
+    async importProviderSession(input) {
+        const resolvedAgentId = validateAgentId(this.idFactory(), "importProviderSession");
+        this.requireEnabledProvider(input.provider);
+        const client = await this.requireAvailableClient({ provider: input.provider });
+        if (!client.importSession) {
+            throw new Error(`Provider '${input.provider}' does not support importing sessions`);
+        }
+        const { storedConfig, launchConfig } = await this.prepareSessionConfig({
+            provider: input.provider,
+            cwd: input.cwd,
+        }, resolvedAgentId);
+        const launchContext = this.buildLaunchContext(resolvedAgentId);
+        const imported = await client.importSession({
+            providerHandleId: input.providerHandleId,
+            cwd: input.cwd,
+        }, { config: launchConfig, storedConfig, launchContext });
+        const importedConfig = await this.normalizeConfig(stripInternalPaseoMcpServer(imported.config));
+        const timelineRows = buildImportedTimelineRows(imported.timeline);
+        const initialTitle = resolveImportedAgentTitle(importedConfig, timelineRows);
+        return this.registerSession(imported.session, importedConfig, resolvedAgentId, {
+            labels: input.labels,
+            timelineRows,
+            timelineNextSeq: timelineRows.length + 1,
+            persistence: imported.persistence,
+            historyPrimed: true,
+            initialTitle,
+            publishWhenReady: true,
+        });
+    }
     // Hot-reload an active agent session with config overrides. By default the
     // in-memory timeline is preserved (used for voice-mode toggles and similar
     // config swaps). When `rehydrateFromDisk` is set, the timeline is wiped so a
@@ -1605,13 +1664,15 @@ export class AgentManager {
         this.agents.set(resolvedAgentId, managed);
         // Initialize previousStatus to track transitions
         this.previousStatuses.set(resolvedAgentId, managed.lifecycle);
-        await this.refreshRuntimeInfo(managed);
+        await this.refreshRuntimeInfo(managed, { emit: !options?.publishWhenReady });
         await this.persistSnapshot(managed, {
             workspaceId: options?.workspaceId,
             title: initialPersistedTitle,
         });
-        this.emitState(managed, { persist: false });
-        await this.refreshSessionState(managed);
+        if (!options?.publishWhenReady) {
+            this.emitState(managed, { persist: false });
+        }
+        await this.refreshSessionState(managed, { emit: !options?.publishWhenReady });
         managed.lifecycle = "idle";
         await this.persistSnapshot(managed, { workspaceId: options?.workspaceId });
         this.emitState(managed, { persist: false });
@@ -1660,7 +1721,7 @@ export class AgentManager {
             foregroundTurnWaiters: new Set(),
             finalizedForegroundTurnIds: new Set(),
             unsubscribeSession: null,
-            persistence: attachPersistenceCwd(session.describePersistence(), config.cwd),
+            persistence: attachPersistenceCwd(options?.persistence ?? session.describePersistence(), config.cwd),
             historyPrimed: options?.historyPrimed ?? durableTimelineHasRows,
             lastUserMessageAt: options?.lastUserMessageAt ?? null,
             lastUsage: options?.lastUsage,
@@ -1812,7 +1873,7 @@ export class AgentManager {
         }
         return this.registry;
     }
-    async refreshSessionState(agent) {
+    async refreshSessionState(agent, options) {
         try {
             const modes = await agent.session.getAvailableModes();
             agent.availableModes = modes;
@@ -1834,9 +1895,9 @@ export class AgentManager {
             agent.pendingPermissions.clear();
         }
         this.syncFeaturesFromSession(agent);
-        await this.refreshRuntimeInfo(agent);
+        await this.refreshRuntimeInfo(agent, options);
     }
-    async refreshRuntimeInfo(agent) {
+    async refreshRuntimeInfo(agent, options) {
         try {
             const newInfo = await agent.session.getRuntimeInfo();
             const changed = newInfo.model !== agent.runtimeInfo?.model ||
@@ -1848,7 +1909,7 @@ export class AgentManager {
                 agent.persistence = attachPersistenceCwd({ provider: agent.provider, sessionId: newInfo.sessionId }, agent.cwd);
             }
             // Emit state if runtimeInfo changed so clients get the updated model
-            if (changed) {
+            if (changed && options?.emit !== false) {
                 this.emitState(agent);
             }
         }

package/dist/server/server/agent/agent-projections.d.ts

@@ -1,6 +1,6 @@
 import type { AgentListItemPayload, AgentSnapshotPayload, RecentProviderSessionDescriptorPayload } from "../messages.js";
 import type { StoredAgentRecord } from "./agent-storage.js";
-import type { AgentProvider, AgentRuntimeInfo, PersistedAgentDescriptor } from "./agent-sdk-types.js";
+import type { AgentProvider, AgentRuntimeInfo, ImportableProviderSession } from "./agent-sdk-types.js";
 import type { ManagedAgent } from "./agent-manager.js";
 export type { ManagedAgent };
 interface ProjectionOptions {
@@ -19,6 +19,8 @@ export declare function toStoredAgentRecord(agent: ManagedAgent, options?: Proje
 export declare function toAgentPayload(agent: ManagedAgent, options?: ProjectionOptions): AgentSnapshotPayload;
 export declare function buildStoredAgentPayload(record: StoredAgentRecord, validProviders: Iterable<AgentProvider>): AgentSnapshotPayload;
 export declare function toAgentListItemPayload(agent: AgentSnapshotPayload): AgentListItemPayload;
-export declare function toRecentProviderSessionDescriptorPayload(descriptor: PersistedAgentDescriptor, options: RecentProviderSessionProjectionOptions): RecentProviderSessionDescriptorPayload;
+export declare function toRecentProviderSessionDescriptorPayload(session: ImportableProviderSession & {
+    provider: string;
+}, options: RecentProviderSessionProjectionOptions): RecentProviderSessionDescriptorPayload;
 export declare function resolveStoredAgentPayloadUpdatedAt(record: StoredAgentRecord): string;
 //# sourceMappingURL=agent-projections.d.ts.map

package/dist/server/server/agent/agent-projections.js

@@ -1,5 +1,4 @@
 import { isStoredAgentProviderAvailable, toAgentPersistenceHandle } from "../persistence-hooks.js";
-const PROMPT_PREVIEW_MAX_LENGTH = 160;
 function normalizeThinkingOptionId(value) {
     if (typeof value !== "string")
         return null;
@@ -193,17 +192,16 @@ export function toAgentListItemPayload(agent) {
         ...(agent.providerUnavailable ? { providerUnavailable: true } : {}),
     };
 }
-export function toRecentProviderSessionDescriptorPayload(descriptor, options) {
-    const promptPreviews = collectPromptPreviews(descriptor.timeline);
+export function toRecentProviderSessionDescriptorPayload(session, options) {
     return {
-        providerId: descriptor.provider,
+        providerId: session.provider,
         providerLabel: options.providerLabel,
-        providerHandleId: descriptor.persistence.nativeHandle ?? descriptor.persistence.sessionId,
-        cwd: descriptor.cwd,
-        title: descriptor.title,
-        firstPromptPreview: promptPreviews[0] ?? null,
-        lastPromptPreview: promptPreviews.at(-1) ?? null,
-        lastActivityAt: descriptor.lastActivityAt.toISOString(),
+        providerHandleId: session.providerHandleId,
+        cwd: session.cwd,
+        title: session.title,
+        firstPromptPreview: session.firstPromptPreview,
+        lastPromptPreview: session.lastPromptPreview,
+        lastActivityAt: session.lastActivityAt.toISOString(),
     };
 }
 export function resolveStoredAgentPayloadUpdatedAt(record) {
@@ -220,24 +218,6 @@ export function resolveStoredAgentPayloadUpdatedAt(record) {
     timestamps.sort((a, b) => b.parsed - a.parsed);
     return timestamps[0].raw;
 }
-function collectPromptPreviews(timeline) {
-    return timeline.flatMap((item) => {
-        if (item.type !== "user_message") {
-            return [];
-        }
-        const preview = normalizePromptPreview(item.text);
-        return preview ? [preview] : [];
-    });
-}
-function normalizePromptPreview(text) {
-    const normalized = text.trim().replace(/\s+/g, " ");
-    if (!normalized) {
-        return null;
-    }
-    return normalized.length > PROMPT_PREVIEW_MAX_LENGTH
-        ? normalized.slice(0, PROMPT_PREVIEW_MAX_LENGTH)
-        : normalized;
-}
 function buildSerializableConfig(config) {
     const serializable = {};
     if (config.modeId) {

package/dist/server/server/agent/agent-sdk-types.d.ts

@@ -135,6 +135,7 @@ export type AgentFeature = AgentFeatureToggle | AgentFeatureSelect;
 export interface AgentCapabilityFlags {
     supportsStreaming: boolean;
     supportsSessionPersistence: boolean;
+    supportsSessionListing?: boolean;
     supportsDynamicModes: boolean;
     supportsMcpServers: boolean;
     supportsReasoningStream: boolean;
@@ -430,6 +431,7 @@ export interface AgentRuntimeInfo {
     modeId?: string | null;
     extra?: AgentMetadata;
 }
+export type AgentSlashCommandKind = "command" | "skill";
 /**
  * Represents a slash command available in an agent session.
  * Commands are executed by sending them as prompts with / prefix.
@@ -438,25 +440,42 @@ export interface AgentSlashCommand {
     name: string;
     description: string;
     argumentHint: string;
+    kind?: AgentSlashCommandKind;
 }
-export interface ListPersistedAgentsOptions {
+export interface ListImportableSessionsOptions {
     limit?: number;
     /**
-     * Optional cwd hint. Providers that can cheaply pre-filter persisted
-     * sessions by working directory should do so before doing expensive
-     * work like fetching turn timelines. Providers that can't filter
-     * cheaply may ignore this hint.
+     * Optional cwd hint. Providers that can cheaply pre-filter importable
+     * sessions by working directory should do so before doing expensive work.
      */
     cwd?: string;
 }
-export interface PersistedAgentDescriptor {
-    provider: AgentProvider;
-    sessionId: string;
+export interface ImportableProviderSession {
+    providerHandleId: string;
     cwd: string;
     title: string | null;
+    firstPromptPreview: string | null;
+    lastPromptPreview: string | null;
     lastActivityAt: Date;
+}
+export interface ImportProviderSessionInput {
+    providerHandleId: string;
+    cwd: string;
+}
+export interface ImportProviderSessionContext {
+    config: AgentSessionConfig;
+    storedConfig: AgentSessionConfig;
+    launchContext?: AgentLaunchContext;
+}
+export interface ImportedTimelineEntry {
+    item: AgentTimelineItem;
+    timestamp?: string;
+}
+export interface ImportedProviderSession {
+    session: AgentSession;
+    config: AgentSessionConfig;
     persistence: AgentPersistenceHandle;
-    timeline: AgentTimelineItem[];
+    timeline: ImportedTimelineEntry[];
 }
 export interface AgentSessionConfig {
     provider: AgentProvider;
@@ -575,7 +594,8 @@ export interface AgentClient {
     isCreateConfigUnattended?(input: AgentCreateConfigUnattendedInput): boolean;
     listCommands?(config: AgentSessionConfig): Promise<AgentSlashCommand[]>;
     listFeatures?(config: AgentSessionConfig): Promise<AgentFeature[]>;
-    listPersistedAgents?(options?: ListPersistedAgentsOptions): Promise<PersistedAgentDescriptor[]>;
+    listImportableSessions?(options?: ListImportableSessionsOptions): Promise<ImportableProviderSession[]>;
+    importSession?(input: ImportProviderSessionInput, context: ImportProviderSessionContext): Promise<ImportedProviderSession>;
     /**
      * Check if this provider is available (CLI binary is installed).
      * Returns true if available, false otherwise.

package/dist/server/server/agent/import-sessions.d.ts

@@ -3,13 +3,14 @@ import type { Logger } from "pino";
 import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
 import type { AgentManager, ManagedAgent } from "./agent-manager.js";
 import type { AgentStorage } from "./agent-storage.js";
+import type { AgentProvider } from "./agent-sdk-types.js";
 import { scheduleAgentMetadataGeneration } from "./agent-metadata-generator.js";
 import type { StructuredGenerationDaemonConfig } from "./structured-generation-providers.js";
 import type { FetchRecentProviderSessionsRequestMessage, ImportAgentRequestMessageSchema, RecentProviderSessionDescriptorPayload } from "@getpaseo/protocol/messages";
 import type { WorkspaceGitService } from "../workspace-git-service.js";
 type ImportAgentRequestMessage = z.infer<typeof ImportAgentRequestMessageSchema>;
 export interface NormalizedImportAgentRequest {
-    provider: string;
+    provider: AgentProvider;
     providerHandleId: string;
     cwd?: string;
     labels?: Record<string, string>;
@@ -21,7 +22,7 @@ export declare class ImportSessionsRequestError extends Error {
 }
 export interface ListImportableProviderSessionsInput {
     request: FetchRecentProviderSessionsRequestMessage;
-    agentManager: Pick<AgentManager, "listAgents" | "listImportablePersistedAgents">;
+    agentManager: Pick<AgentManager, "listAgents" | "listImportableSessions">;
     agentStorage: Pick<AgentStorage, "list">;
     providerSnapshotManager: Pick<ProviderSnapshotManager, "getProviderLabel">;
 }

package/dist/server/server/agent/import-sessions.js

@@ -23,7 +23,7 @@ export function normalizeImportAgentRequest(msg) {
         return { error: "Import requires providerId and providerHandleId" };
     }
     return {
-        provider,
+        provider: provider,
         providerHandleId,
         cwd: msg.cwd,
         labels: msg.labels,
@@ -36,7 +36,7 @@ export async function listImportableProviderSessions(input) {
     const sinceTimestamp = parseRecentProviderSessionsSince(request.since);
     const providerFilter = request.providers ? new Set(request.providers) : undefined;
     const importedHandles = await collectImportedProviderSessionHandles(agentManager, agentStorage);
-    const descriptors = await agentManager.listImportablePersistedAgents({
+    const sessions = await agentManager.listImportableSessions({
         limit,
         providerFilter,
         cwd: request.cwd,
@@ -44,25 +44,21 @@ export async function listImportableProviderSessions(input) {
     let filteredAlreadyImportedCount = 0;
     const candidates = [];
     const matchesRequestCwd = request.cwd ? createRealpathAwarePathMatcher(request.cwd) : null;
-    for (const descriptor of descriptors) {
-        if (matchesRequestCwd && !matchesRequestCwd(descriptor.cwd)) {
-            continue;
-        }
-        if (sinceTimestamp !== null && descriptor.lastActivityAt.getTime() < sinceTimestamp) {
+    for (const session of sessions) {
+        if (matchesRequestCwd && !matchesRequestCwd(session.cwd)) {
             continue;
         }
-        if (isMetadataGenerationDescriptor(descriptor)) {
+        if (sinceTimestamp !== null && session.lastActivityAt.getTime() < sinceTimestamp) {
             continue;
         }
-        if (!hasUserPrompt(descriptor)) {
+        if (isMetadataGenerationSession(session)) {
             continue;
         }
-        const providerHandleId = descriptor.persistence.nativeHandle ?? descriptor.persistence.sessionId;
-        if (importedHandles.has(toProviderSessionHandleKey(descriptor.provider, providerHandleId))) {
+        if (importedHandles.has(toProviderSessionHandleKey(session.provider, session.providerHandleId))) {
             filteredAlreadyImportedCount += 1;
             continue;
         }
-        candidates.push(descriptor);
+        candidates.push(session);
     }
     const entries = candidates
         .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
@@ -74,23 +70,19 @@ export async function listImportableProviderSessions(input) {
 }
 export async function importProviderSession(input) {
     const { provider, providerHandleId, cwd, labels } = input.request;
-    const descriptor = await input.agentManager.findPersistedAgent(provider, providerHandleId, {
-        cwd,
-    });
-    if (!descriptor && provider === "opencode" && !cwd) {
-        throw new Error("OpenCode sessions require --cwd when the session cannot be found in persisted agents");
+    if (!cwd) {
+        throw new Error("Import requires cwd from the selected provider session");
     }
-    const handle = descriptor
-        ? applyImportCwdOverride(descriptor.persistence, cwd)
-        : buildImportPersistenceHandle({ provider, providerHandleId, cwd });
-    const overrides = cwd ? { cwd } : undefined;
+    const handle = buildImportPersistenceHandle({ provider, providerHandleId, cwd });
     await unarchiveAgentByHandle(input.agentStorage, input.agentManager, handle);
-    const snapshot = await input.agentManager.resumeAgentFromPersistence(handle, overrides, undefined, {
+    const snapshot = await input.agentManager.importProviderSession({
+        provider,
+        providerHandleId,
+        cwd,
         labels,
     });
     await unarchiveAgentState(input.agentStorage, input.agentManager, snapshot.id);
-    await input.agentManager.hydrateTimelineFromProvider(snapshot.id);
-    await applyImportedAgentTitle({
+    scheduleImportedAgentMetadata({
         snapshot,
         agentManager: input.agentManager,
         workspaceGitService: input.workspaceGitService,
@@ -108,24 +100,22 @@ export async function importProviderSession(input) {
 async function unarchiveAgentByHandle(agentStorage, agentManager, handle) {
     const records = await agentStorage.list();
     const matched = records.find((record) => record.persistence?.provider === handle.provider &&
-        record.persistence?.sessionId === handle.sessionId);
+        (record.persistence.sessionId === handle.sessionId ||
+            record.persistence.nativeHandle === handle.nativeHandle));
     if (!matched) {
         return;
     }
     await unarchiveAgentState(agentStorage, agentManager, matched.id);
 }
-async function applyImportedAgentTitle(input) {
+function scheduleImportedAgentMetadata(input) {
     const initialPrompt = getFirstUserMessageText(input.agentManager.getTimeline(input.snapshot.id));
     if (!initialPrompt) {
         return;
     }
-    const { explicitTitle, provisionalTitle } = resolveCreateAgentTitles({
+    const { explicitTitle } = resolveCreateAgentTitles({
         configTitle: input.snapshot.config.title,
         initialPrompt,
     });
-    if (!explicitTitle && provisionalTitle) {
-        await input.agentManager.setTitle(input.snapshot.id, provisionalTitle);
-    }
     input.scheduleAgentMetadataGeneration({
         agentManager: input.agentManager,
         agentId: input.snapshot.id,
@@ -157,27 +147,13 @@ function parseRecentProviderSessionsSince(since) {
     return timestamp;
 }
 function buildImportPersistenceHandle(input) {
-    const cwd = input.cwd ?? process.cwd();
     return {
         provider: input.provider,
         sessionId: input.providerHandleId,
         nativeHandle: input.providerHandleId,
         metadata: {
             provider: input.provider,
-            cwd,
-        },
-    };
-}
-function applyImportCwdOverride(handle, cwd) {
-    if (!cwd) {
-        return handle;
-    }
-    return {
-        ...handle,
-        metadata: {
-            ...handle.metadata,
-            provider: handle.provider,
-            cwd,
+            cwd: input.cwd,
         },
     };
 }
@@ -206,16 +182,8 @@ async function collectImportedProviderSessionHandles(agentManager, agentStorage)
 function toProviderSessionHandleKey(provider, providerHandleId) {
     return `${provider}\0${providerHandleId}`;
 }
-function isMetadataGenerationDescriptor(descriptor) {
-    for (const item of descriptor.timeline) {
-        if (item.type !== "user_message")
-            continue;
-        return item.text.trimStart().startsWith(METADATA_GENERATION_PROMPT_PREFIX);
-    }
-    return false;
-}
-function hasUserPrompt(descriptor) {
-    return descriptor.timeline.some((item) => item.type === "user_message" && item.text.trim() !== "");
+function isMetadataGenerationSession(input) {
+    return (input.firstPromptPreview?.trimStart().startsWith(METADATA_GENERATION_PROMPT_PREFIX) ?? false);
 }
 function collectProviderSessionHandleKeys(target, provider, persistence) {
     if (!persistence) {

package/dist/server/server/agent/provider-registry.js

@@ -141,16 +141,6 @@ function mapStreamEvent(provider, event) {
         provider,
     };
 }
-function mapPersistedAgentDescriptor(provider, descriptor) {
-    return {
-        ...descriptor,
-        provider,
-        persistence: {
-            ...descriptor.persistence,
-            provider,
-        },
-    };
-}
 function mapModel(provider, model) {
     return normalizeAgentModelDefinition({ ...model, provider });
 }
@@ -222,7 +212,8 @@ export function wrapSessionProvider(provider, inner) {
     };
 }
 function wrapClientProvider(provider, inner, profileModels, additionalModels, profileModelsAreAdditive) {
-    const listPersistedAgents = inner.listPersistedAgents?.bind(inner);
+    const listImportableSessions = inner.listImportableSessions?.bind(inner);
+    const importSession = inner.importSession?.bind(inner);
     return {
         provider,
         capabilities: inner.capabilities,
@@ -245,8 +236,36 @@ function wrapClientProvider(provider, inner, profileModels, additionalModels, pr
         listModes: inner.listModes?.bind(inner),
         resolveCreateConfig: inner.resolveCreateConfig?.bind(inner),
         isCreateConfigUnattended: inner.isCreateConfigUnattended?.bind(inner),
-        listPersistedAgents: listPersistedAgents
-            ? async (options) => (await listPersistedAgents(options)).map((descriptor) => mapPersistedAgentDescriptor(provider, descriptor))
+        listImportableSessions: listImportableSessions
+            ? async (options) => await listImportableSessions(options)
+            : undefined,
+        importSession: importSession
+            ? async (input, context) => {
+                const imported = await importSession(input, {
+                    ...context,
+                    config: {
+                        ...context.config,
+                        provider: inner.provider,
+                    },
+                    storedConfig: {
+                        ...context.storedConfig,
+                        provider: inner.provider,
+                    },
+                });
+                const persistence = mapPersistenceHandle(provider, imported.persistence);
+                if (!persistence) {
+                    throw new Error(`Provider '${provider}' import did not return persistence`);
+                }
+                return {
+                    ...imported,
+                    session: wrapSessionProvider(provider, imported.session),
+                    config: {
+                        ...imported.config,
+                        provider,
+                    },
+                    persistence,
+                };
+            }
             : undefined,
         isAvailable: () => inner.isAvailable(),
         getDiagnostic: inner.getDiagnostic?.bind(inner),
@@ -352,6 +371,7 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
                         env: override.env,
                         providerId,
                         label: override.label ?? providerId,
+                        providerParams: override.params,
                     })
                     : new GenericACPAgentClient({
                         logger,
@@ -359,6 +379,7 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
                         env: override.env,
                         providerId,
                         label: override.label ?? providerId,
+                        providerParams: override.params,
                     }),
             });
             continue;