@getpaseo/server 0.1.91-beta.2 → 0.1.92

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/prompt-attachments.js

@@ -45,6 +45,14 @@ export function renderPromptAttachmentAsText(attachment) {
             });
             return lines.join("\n");
         }
+        case "uploaded_file": {
+            return [
+                `Uploaded file: ${attachment.fileName}`,
+                `Path: ${attachment.path}`,
+                `MIME: ${attachment.mimeType}`,
+                `Size: ${attachment.size} bytes`,
+            ].join("\n");
+        }
         default:
             throw new Error("unreachable");
     }

package/dist/server/server/agent/provider-registry.d.ts

@@ -19,7 +19,6 @@ export interface ProviderDefinition extends AgentProviderDefinition {
     fetchModels: (options: ListModelsOptions) => Promise<AgentModelDefinition[]>;
     fetchModes: (options: ListModesOptions) => Promise<AgentMode[]>;
 }
-export { IMPORTABLE_PROVIDERS } from "@getpaseo/protocol/importable-providers";
 export interface BuildProviderRegistryOptions {
     runtimeSettings?: AgentProviderRuntimeSettingsMap;
     providerOverrides?: Record<string, ProviderOverride>;

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

@@ -14,7 +14,6 @@ function isNonEmptyStringArray(value) {
     return value.length > 0;
 }
 export { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition };
-export { IMPORTABLE_PROVIDERS } from "@getpaseo/protocol/importable-providers";
 const PROVIDER_CLIENT_FACTORIES = {
     claude: (logger, runtimeSettings) => new ClaudeAgentClient({
         logger,
@@ -34,9 +33,22 @@ const PROVIDER_CLIENT_FACTORIES = {
         env: runtimeSettings?.env,
     }),
     opencode: (logger, runtimeSettings) => new OpenCodeAgentClient(logger, runtimeSettings),
-    pi: (logger, runtimeSettings) => new PiRpcAgentClient({
+    pi: (logger, runtimeSettings, options) => new PiRpcAgentClient({
         logger,
         runtimeSettings,
+        providerParams: options?.providerParams,
+    }),
+    omp: (logger, runtimeSettings, options) => new PiRpcAgentClient({
+        logger,
+        runtimeSettings: mergeRuntimeSettings({
+            command: {
+                mode: "replace",
+                argv: ["omp"],
+            },
+        }, runtimeSettings),
+        providerParams: options?.providerParams ?? {
+            sessionDir: "~/.omp/agent/sessions",
+        },
     }),
     mock: (logger) => new MockLoadTestAgentClient(logger),
     "mock-slow": () => new MockSlowProviderClient(),
@@ -129,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 });
 }
@@ -210,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,
@@ -233,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),
@@ -293,10 +324,12 @@ function buildResolvedBuiltinProviders(providerOverrides, runtimeSettings, optio
             profileModels: override?.models ?? [],
             additionalModels: override?.additionalModels ?? [],
             profileModelsAreAdditive: false,
-            enabled: override?.enabled !== false,
+            enabled: override?.enabled ?? definition.enabledByDefault ?? true,
             derivedFromProviderId: null,
+            providerParams: override?.params,
             createBaseClient: (logger) => factory(logger, mergedRuntimeSettings, {
                 workspaceGitService: options.workspaceGitService,
+                providerParams: override?.params,
             }),
         });
     }
@@ -330,6 +363,7 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
                 profileModelsAreAdditive: false,
                 enabled: override.enabled !== false,
                 derivedFromProviderId: null,
+                providerParams: override.params,
                 createBaseClient: (logger) => providerId === "cursor"
                     ? new CursorACPAgentClient({
                         logger,
@@ -337,6 +371,7 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
                         env: override.env,
                         providerId,
                         label: override.label ?? providerId,
+                        providerParams: override.params,
                     })
                     : new GenericACPAgentClient({
                         logger,
@@ -344,6 +379,7 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
                         env: override.env,
                         providerId,
                         label: override.label ?? providerId,
+                        providerParams: override.params,
                     }),
             });
             continue;
@@ -356,6 +392,7 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
         const mergedRuntimeSettings = mergeRuntimeSettings(baseProvider.runtimeSettings, toRuntimeSettings(override));
         const baseDefinition = baseProvider.definition;
         const baseFactory = getProviderClientFactory(baseProviderId);
+        const providerParams = override.params ?? baseProvider.providerParams;
         resolvedProviders.set(providerId, {
             definition: createDerivedDefinition(providerId, baseDefinition, override),
             runtimeSettings: mergedRuntimeSettings,
@@ -364,7 +401,9 @@ function addDerivedProviders(resolvedProviders, providerOverrides) {
             profileModelsAreAdditive: false,
             enabled: override.enabled !== false,
             derivedFromProviderId: baseProviderId,
+            providerParams,
             createBaseClient: (logger) => baseFactory(logger, mergedRuntimeSettings, {
+                providerParams,
                 customProvider: {
                     id: providerId,
                     label: override.label ?? providerId,

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;