@getpaseo/server 0.1.91-beta.2 → 0.1.92

package/dist/scripts/supervisor.js

@@ -127,6 +127,26 @@ export function runSupervisor(options) {
                 execArgv: workerExecArgv,
             });
         }
+        const currentChild = child;
+        const heartbeat = setInterval(() => {
+            const message = { type: "paseo:supervisor-heartbeat" };
+            if (currentChild.connected) {
+                currentChild.send?.(message, (error) => {
+                    if (error) {
+                        writeLifecycleLog("Worker heartbeat IPC send failed", {
+                            error: error instanceof Error ? error.message : String(error),
+                        });
+                    }
+                });
+            }
+            else {
+                writeLifecycleLog("Worker heartbeat skipped because IPC channel is disconnected");
+            }
+        }, 1000);
+        heartbeat.unref();
+        child.on("disconnect", () => {
+            writeLifecycleLog("Worker IPC channel disconnected");
+        });
         child.stdout?.on("data", (chunk) => {
             process.stdout.write(chunk);
             writeDurableChunk(chunk);
@@ -157,6 +177,7 @@ export function runSupervisor(options) {
             requestRestart("Restart requested by worker");
         });
         child.on("close", (code, signal) => {
+            clearInterval(heartbeat);
             const exitDescriptor = describeExit(code, signal);
             writeLifecycleLog("Worker exited", { code, signal, exit: exitDescriptor });
             if (shuttingDown) {

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;
@@ -163,7 +166,6 @@ export interface AgentMetricsSnapshot {
 export declare class AgentManager {
     private readonly clients;
     private readonly providerEnabled;
-    private readonly providerDerivedFromId;
     private readonly agents;
     private readonly timelineStore;
     private readonly agentsAwaitingInitialSnapshotPersist;
@@ -199,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[]>;
@@ -224,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>;
@@ -337,6 +344,7 @@ export declare class AgentManager {
     private dispatchStream;
     private dispatch;
     private normalizeConfig;
+    private prepareSessionConfig;
     private applyDaemonAppendSystemPrompt;
     private buildLaunchContext;
     private requireAvailableClient;

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

@@ -10,9 +10,10 @@ import { InMemoryAgentTimelineStore, } from "./agent-timeline-store.js";
 import { AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS, AgentStreamCoalescer, } from "./agent-stream-coalescer.js";
 import { ForegroundRunState } from "./foreground-run-state.js";
 import { getAgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
-import { IMPORTABLE_PROVIDERS } from "./provider-registry.js";
 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 = {
@@ -54,7 +55,7 @@ function buildStoredAgentConfig(record) {
     }
     if (record.config.mcpServers != null)
         config.mcpServers = record.config.mcpServers;
-    return config;
+    return stripInternalPaseoMcpServer(config);
 }
 export { AGENT_LIFECYCLE_STATUSES };
 function resolveInitialAttention(input) {
@@ -122,11 +123,48 @@ 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();
         this.providerEnabled = new Map();
-        this.providerDerivedFromId = new Map();
         this.agents = new Map();
         this.timelineStore = new InMemoryAgentTimelineStore();
         this.agentsAwaitingInitialSnapshotPersist = new Set();
@@ -166,7 +204,6 @@ export class AgentManager {
         for (const [provider, definition] of Object.entries(input.providerDefinitions)) {
             if (definition) {
                 this.providerEnabled.set(provider, definition.enabled);
-                this.providerDerivedFromId.set(provider, definition.derivedFromProviderId ?? null);
             }
         }
         for (const [provider, client] of Object.entries(input.clients)) {
@@ -281,52 +318,37 @@ 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);
     }
     isProviderImportable(provider, providerFilter) {
-        if (!IMPORTABLE_PROVIDERS.includes(provider)) {
-            return false;
-        }
         if (this.providerEnabled.get(provider) === false) {
             return false;
         }
-        if (this.providerDerivedFromId.get(provider) != null) {
-            return false;
-        }
         if (providerFilter && !providerFilter.has(provider)) {
             return false;
         }
         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);
@@ -427,27 +449,15 @@ export class AgentManager {
     }
     async createAgent(config, agentId, options) {
         const resolvedAgentId = validateAgentId(agentId ?? this.idFactory(), "createAgent");
-        const injectedConfig = this.mcpBaseUrl == null
-            ? config
-            : {
-                ...config,
-                mcpServers: {
-                    paseo: {
-                        type: "http",
-                        url: `${this.mcpBaseUrl}?callerAgentId=${resolvedAgentId}`,
-                    },
-                    ...config.mcpServers,
-                },
-            };
-        this.requireEnabledProvider(injectedConfig.provider);
-        const normalizedConfig = this.applyDaemonAppendSystemPrompt(await this.normalizeConfig(injectedConfig));
+        const { storedConfig, launchConfig } = await this.prepareSessionConfig(config, resolvedAgentId);
+        this.requireEnabledProvider(storedConfig.provider);
         const launchContext = this.buildLaunchContext(resolvedAgentId, options?.env);
         const client = await this.requireAvailableClient({
-            provider: normalizedConfig.provider,
+            provider: storedConfig.provider,
         });
         const createOptions = this.buildCreateSessionOptions(options);
-        const session = await client.createSession(normalizedConfig, launchContext, createOptions);
-        return this.registerSession(session, normalizedConfig, resolvedAgentId, {
+        const session = await client.createSession(launchConfig, launchContext, createOptions);
+        return this.registerSession(session, storedConfig, resolvedAgentId, {
             labels: options?.labels,
             workspaceId: options?.workspaceId,
             initialTitle: options?.initialTitle,
@@ -468,29 +478,44 @@ export class AgentManager {
             ...overrides,
             provider: handle.provider,
         };
-        const normalizedConfig = this.applyDaemonAppendSystemPrompt(await this.normalizeConfig(mergedConfig));
-        const resumeOverrides = { ...overrides };
-        let hasResumeOverrides = overrides !== undefined;
-        if (normalizedConfig.model !== mergedConfig.model) {
-            resumeOverrides.model = normalizedConfig.model;
-            hasResumeOverrides = true;
-        }
-        if (normalizedConfig.modeId !== mergedConfig.modeId) {
-            resumeOverrides.modeId = normalizedConfig.modeId;
-            hasResumeOverrides = true;
-        }
-        if (metadata.daemonAppendSystemPrompt !== normalizedConfig.daemonAppendSystemPrompt) {
-            resumeOverrides.daemonAppendSystemPrompt = normalizedConfig.daemonAppendSystemPrompt;
-            hasResumeOverrides = true;
-        }
+        const { storedConfig, launchConfig } = await this.prepareSessionConfig(mergedConfig, resolvedAgentId);
         const launchContext = this.buildLaunchContext(resolvedAgentId);
         const client = this.requireClient(handle.provider);
         const available = await client.isAvailable();
         if (!available) {
             throw new Error(`Provider '${handle.provider}' is not available. Please ensure the CLI is installed.`);
         }
-        const session = await client.resumeSession(handle, hasResumeOverrides ? resumeOverrides : undefined, launchContext);
-        return this.registerSession(session, normalizedConfig, resolvedAgentId, options);
+        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
@@ -517,11 +542,11 @@ export class AgentManager {
             ...overrides,
             provider,
         };
-        const normalizedConfig = this.applyDaemonAppendSystemPrompt(await this.normalizeConfig(refreshConfig));
+        const { storedConfig, launchConfig } = await this.prepareSessionConfig(refreshConfig, agentId);
         const launchContext = this.buildLaunchContext(agentId);
         const session = handle
-            ? await client.resumeSession(handle, normalizedConfig, launchContext)
-            : await client.createSession(normalizedConfig, launchContext);
+            ? await client.resumeSession(handle, launchConfig, launchContext)
+            : await client.createSession(launchConfig, launchContext);
         this.agentStreamCoalescer.flushAndDiscard(agentId);
         // Remove the existing agent entry before swapping sessions
         this.agents.delete(agentId);
@@ -539,7 +564,7 @@ export class AgentManager {
             this.timelineStore.delete(agentId);
         }
         // Preserve existing labels and timeline during reload.
-        return this.registerSession(session, normalizedConfig, agentId, {
+        return this.registerSession(session, storedConfig, agentId, {
             labels: existing.labels,
             createdAt: existing.createdAt,
             updatedAt: existing.updatedAt,
@@ -1639,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 });
@@ -1694,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,
@@ -1846,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;
@@ -1868,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 ||
@@ -1882,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);
             }
         }
@@ -2503,6 +2530,15 @@ export class AgentManager {
         }
         return normalized;
     }
+    async prepareSessionConfig(config, agentId) {
+        const storedConfig = await this.normalizeConfig(stripInternalPaseoMcpServer(config));
+        const launchConfig = this.applyDaemonAppendSystemPrompt(withRuntimePaseoMcpServer({
+            config: storedConfig,
+            agentId,
+            mcpBaseUrl: this.mcpBaseUrl,
+        }));
+        return { storedConfig, launchConfig };
+    }
     applyDaemonAppendSystemPrompt(config) {
         const daemonAppendSystemPrompt = this.appendSystemPrompt.trim();
         const next = { ...config };

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">;
 }