@getpaseo/server 0.1.100 → 0.1.102-beta.2

package/dist/server/server/agent/prompt-attachments.js

@@ -67,14 +67,18 @@ export function buildAgentBranchNameSeed(firstAgentContext) {
     const parts = [];
     const prompt = firstAgentContext.prompt?.trim();
     if (prompt) {
-        parts.push(prompt);
+        parts.push(["<user-prompt>", prompt, "</user-prompt>"].join("\n"));
     }
+    const renderedAttachments = [];
     for (const attachment of firstAgentContext.attachments ?? []) {
         const rendered = renderPromptAttachmentAsText(attachment).trim();
         if (rendered) {
-            parts.push(rendered);
+            renderedAttachments.push(rendered);
         }
     }
+    if (renderedAttachments.length > 0) {
+        parts.push(["<attachments>", renderedAttachments.join("\n\n"), "</attachments>"].join("\n"));
+    }
     return parts.length > 0 ? parts.join("\n\n") : undefined;
 }
 //# sourceMappingURL=prompt-attachments.js.map

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

@@ -5,6 +5,7 @@ import type { WorkspaceGitService } from "../workspace-git-service.js";
 import type { ManagedProcessRegistry } from "../managed-processes/managed-processes.js";
 import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./provider-launch-config.js";
 import type { MutableDaemonConfig } from "../daemon-config-store.js";
+export declare const GLOBAL_PROVIDER_SNAPSHOT_KEY = "paseo:global";
 type ProviderSnapshotChangeListener = (entries: ProviderSnapshotEntry[], cwd: string) => void;
 export interface ProviderSnapshotManagerOptions {
     logger: Logger;
@@ -15,11 +16,16 @@ export interface ProviderSnapshotManagerOptions {
     isDev?: boolean;
     extraClients?: Partial<Record<AgentProvider, AgentClient>>;
     refreshTimeoutMs?: number;
+    diagnosticTimeoutMs?: number;
 }
 interface ProviderSnapshotRefreshOptions {
     cwd: string;
     providers?: AgentProvider[];
 }
+interface ProviderSnapshotWarmUpOptions {
+    cwd?: string | null;
+    providers?: AgentProvider[];
+}
 interface ProviderSnapshotReadOptions {
     cwd?: string | null;
     providers?: AgentProvider[];
@@ -64,6 +70,7 @@ export declare class ProviderSnapshotManager {
     private readonly events;
     private destroyed;
     private readonly refreshTimeoutMs;
+    private readonly diagnosticTimeoutMs;
     private readonly logger;
     private readonly workspaceGitService?;
     private readonly managedProcesses?;
@@ -78,7 +85,7 @@ export declare class ProviderSnapshotManager {
     getSnapshot(cwd?: string): ProviderSnapshotEntry[];
     refreshSnapshotForCwd(options: ProviderSnapshotRefreshOptions): Promise<void>;
     refreshSettingsSnapshot(options?: Omit<ProviderSnapshotRefreshOptions, "cwd">): Promise<void>;
-    warmUpSnapshotForCwd(options: ProviderSnapshotRefreshOptions): Promise<void>;
+    warmUpSnapshotForCwd(options: ProviderSnapshotWarmUpOptions): Promise<void>;
     refresh(options: ProviderSnapshotRefreshOptions): Promise<void>;
     listRegisteredProviderIds(): AgentProvider[];
     hasProvider(provider: AgentProvider): boolean;
@@ -99,8 +106,11 @@ export declare class ProviderSnapshotManager {
     destroy(): void;
     private buildRegistry;
     private resolveParent;
+    private getSnapshotForTarget;
     private getReadyProvider;
     private requireProvider;
+    private refreshDiagnosticSnapshotEntry;
+    private getBaseProviderDiagnostic;
     private createLoadingEntries;
     private reconcileSnapshotForRegistry;
     private warmUp;
@@ -120,5 +130,6 @@ export declare class ProviderSnapshotManager {
     private resolveRefreshProviders;
 }
 export declare function resolveSnapshotCwd(cwd?: string | null): string;
+export declare function isGlobalProviderSnapshotKey(cwd: string): boolean;
 export {};
 //# sourceMappingURL=provider-snapshot-manager.d.ts.map

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

@@ -5,9 +5,11 @@ import { expandTilde } from "../../utils/path.js";
 import { withTimeout } from "../../utils/promise-timeout.js";
 import { buildProviderRegistry, shutdownAgentClients, } from "./provider-registry.js";
 import { applyMutableProviderConfigToOverrides } from "../daemon-config-store.js";
-import { formatProviderDiagnostic } from "./providers/diagnostic-utils.js";
-const DEFAULT_REFRESH_TIMEOUT_MS = 30000;
+import { formatProviderDiagnostic, formatProviderDiagnosticError, } from "./providers/diagnostic-utils.js";
+const DEFAULT_REFRESH_TIMEOUT_MS = 60000;
+const DEFAULT_DIAGNOSTIC_TIMEOUT_MS = 120000;
 const REFRESH_TIMEOUT_ENV_VAR = "PASEO_PROVIDER_REFRESH_TIMEOUT_MS";
+export const GLOBAL_PROVIDER_SNAPSHOT_KEY = "paseo:global";
 // Provider refresh probes can be slow on cold starts (e.g. Copilot's first
 // `copilot --acp` invocation, OpenCode workspace probes with many MCP servers).
 // Allow operators to bump the ceiling via env var without rebuilding.
@@ -25,6 +27,12 @@ function resolveRefreshTimeoutMs(option) {
     }
     return DEFAULT_REFRESH_TIMEOUT_MS;
 }
+function resolveDiagnosticTimeoutMs(option, refreshTimeoutMs) {
+    if (typeof option === "number" && Number.isFinite(option) && option > 0) {
+        return option;
+    }
+    return Math.max(refreshTimeoutMs, DEFAULT_DIAGNOSTIC_TIMEOUT_MS);
+}
 export class ProviderSnapshotManager {
     constructor(options) {
         this.snapshots = new Map();
@@ -40,35 +48,35 @@ export class ProviderSnapshotManager {
         this.providerOverrides = options.providerOverrides;
         this.baseProviderOverrides = options.providerOverrides;
         this.refreshTimeoutMs = resolveRefreshTimeoutMs(options.refreshTimeoutMs);
+        this.diagnosticTimeoutMs = resolveDiagnosticTimeoutMs(options.diagnosticTimeoutMs, this.refreshTimeoutMs);
         this.providerRegistry = this.buildRegistry();
         this.providerClients = { ...this.extraClients };
     }
     getSnapshot(cwd) {
-        const resolvedCwd = resolveSnapshotCwd(cwd);
-        const providersToWarm = this.resolveProvidersToWarm(resolvedCwd);
-        if (providersToWarm.length > 0) {
-            void this.warmUp(resolvedCwd, providersToWarm);
-        }
-        return entriesToArray(this.getOrCreateSnapshot(resolvedCwd));
+        const target = resolveProviderSnapshotTarget(cwd);
+        return this.getSnapshotForTarget(target);
     }
     async refreshSnapshotForCwd(options) {
         const snapshotCwd = resolveSnapshotCwd(options.cwd);
+        const target = createWorkspaceSnapshotTarget(snapshotCwd);
         const providers = this.resolveRefreshProviders(options.providers);
         this.resetSnapshotToLoading(snapshotCwd, providers, { preserveExisting: false });
         this.emitChange(snapshotCwd);
-        await this.refreshProviders(snapshotCwd, providers ?? this.getProviderIds());
+        await this.refreshProviders(target, providers ?? this.getProviderIds());
     }
     async refreshSettingsSnapshot(options = {}) {
-        const homeCwd = resolveSnapshotCwd();
+        const target = createGlobalSnapshotTarget();
+        const homeCwd = target.snapshotCwd;
         const providers = this.resolveRefreshProviders(options.providers);
         const providersToRefresh = providers ?? this.getProviderIds();
         this.clearCachedProviders(providers);
         this.resetSnapshotToLoading(homeCwd, providers, { preserveExisting: false });
         this.emitChange(homeCwd);
-        await this.refreshProviders(homeCwd, providersToRefresh);
+        await this.refreshProviders(target, providersToRefresh);
     }
     async warmUpSnapshotForCwd(options) {
-        const snapshotCwd = resolveSnapshotCwd(options.cwd);
+        const target = resolveProviderSnapshotTarget(options.cwd);
+        const snapshotCwd = target.snapshotCwd;
         const providers = this.resolveRefreshProviders(options.providers);
         if (options.providers && providers?.length === 0) {
             return;
@@ -77,7 +85,7 @@ export class ProviderSnapshotManager {
         if (providersToWarm.length === 0) {
             return;
         }
-        await this.warmUp(snapshotCwd, providersToWarm);
+        await this.warmUp(target, providersToWarm);
     }
     async refresh(options) {
         await this.refreshSnapshotForCwd(options);
@@ -120,12 +128,12 @@ export class ProviderSnapshotManager {
         return client;
     }
     async listProviders(input = {}) {
-        const cwd = resolveSnapshotCwd(input.cwd);
+        const target = resolveProviderSnapshotTarget(input.cwd);
         if (input.wait) {
-            await this.warmUpSnapshotForCwd({ cwd, providers: input.providers });
+            await this.warmUpSnapshotForCwd({ cwd: input.cwd, providers: input.providers });
         }
         const providerFilter = input.providers ? new Set(input.providers) : null;
-        const entries = this.getSnapshot(cwd);
+        const entries = this.getSnapshotForTarget(target);
         return providerFilter ? entries.filter((entry) => providerFilter.has(entry.provider)) : entries;
     }
     async getProvider(input) {
@@ -180,18 +188,23 @@ export class ProviderSnapshotManager {
         });
     }
     async getProviderDiagnostic(provider) {
-        const definition = this.requireProvider(provider);
-        const client = this.ensureClient(provider, definition);
-        // Force-refresh the snapshot so Models/Status come from the single catalog authority.
-        await this.refreshSnapshotForCwd({ cwd: homedir(), providers: [provider] });
-        const entry = await this.getProvider({ cwd: homedir(), provider, wait: true });
+        const definition = this.providerRegistry[provider];
+        if (!definition) {
+            return {
+                provider,
+                diagnostic: formatProviderDiagnostic(provider, [
+                    { label: "Error", value: `Provider ${provider} is not configured` },
+                ]),
+            };
+        }
+        const baseDiagnosticPromise = this.getBaseProviderDiagnostic(provider, definition);
+        const snapshotEntryPromise = this.refreshDiagnosticSnapshotEntry(provider, definition);
+        const [baseDiagnostic, entry] = await Promise.all([
+            baseDiagnosticPromise,
+            snapshotEntryPromise,
+        ]);
         const modelCount = entry.status === "ready" ? String(entry.models?.length ?? 0) : "—";
         const status = formatProviderStatus(entry);
-        const baseDiagnostic = client.getDiagnostic
-            ? (await client.getDiagnostic()).diagnostic
-            : formatProviderDiagnostic(definition.label ?? provider, [
-                { label: "Diagnostic", value: "No diagnostic available" },
-            ]);
         const diagnostic = `${baseDiagnostic}\n  Models: ${modelCount}\n  Status: ${status}`;
         return { provider, diagnostic };
     }
@@ -263,6 +276,13 @@ export class ProviderSnapshotManager {
             }),
         };
     }
+    getSnapshotForTarget(target) {
+        const providersToWarm = this.resolveProvidersToWarm(target.snapshotCwd);
+        if (providersToWarm.length > 0) {
+            void this.warmUp(target, providersToWarm);
+        }
+        return entriesToArray(this.getOrCreateSnapshot(target.snapshotCwd));
+    }
     async getReadyProvider(input) {
         const entry = await this.getProvider(input);
         if (!entry.enabled) {
@@ -283,6 +303,40 @@ export class ProviderSnapshotManager {
         }
         return definition;
     }
+    async refreshDiagnosticSnapshotEntry(provider, definition) {
+        try {
+            const target = createGlobalSnapshotTarget();
+            this.resetSnapshotToLoading(target.snapshotCwd, [provider], { preserveExisting: false });
+            this.emitChange(target.snapshotCwd);
+            await this.refreshProviders(target, [provider]);
+            return await this.getProvider({ provider, wait: false });
+        }
+        catch (error) {
+            return {
+                provider,
+                status: "error",
+                enabled: definition.enabled,
+                label: definition.label,
+                description: definition.description,
+                defaultModeId: definition.defaultModeId,
+                error: toErrorMessage(error),
+            };
+        }
+    }
+    async getBaseProviderDiagnostic(provider, definition) {
+        try {
+            const client = this.ensureClient(provider, definition);
+            if (client.getDiagnostic) {
+                return (await withTimeout(client.getDiagnostic(), this.diagnosticTimeoutMs, `Timed out collecting ${definition.label ?? provider} diagnostic after ${this.diagnosticTimeoutMs}ms`)).diagnostic;
+            }
+            return formatProviderDiagnostic(definition.label ?? provider, [
+                { label: "Diagnostic", value: "No diagnostic available" },
+            ]);
+        }
+        catch (error) {
+            return formatProviderDiagnosticError(definition.label ?? provider, error);
+        }
+    }
     createLoadingEntries() {
         const entries = new Map();
         for (const provider of this.getProviderIds()) {
@@ -326,16 +380,22 @@ export class ProviderSnapshotManager {
         }
         return entries;
     }
-    async warmUp(cwd, providers) {
+    async warmUp(target, providers) {
         const providersToRefresh = providers ?? this.getProviderIds();
         await this.loadProviders({
-            cwd,
+            snapshotCwd: target.snapshotCwd,
+            catalogScope: target.catalogScope,
             providers: providersToRefresh,
             force: false,
         });
     }
-    async refreshProviders(cwd, providers) {
-        await this.loadProviders({ cwd, providers, force: true });
+    async refreshProviders(target, providers) {
+        await this.loadProviders({
+            snapshotCwd: target.snapshotCwd,
+            catalogScope: target.catalogScope,
+            providers,
+            force: true,
+        });
     }
     resolveProvidersToWarm(cwd, providers) {
         const providersToInspect = providers ?? this.getProviderIds();
@@ -395,40 +455,41 @@ export class ProviderSnapshotManager {
         if (!definition) {
             return Promise.resolve();
         }
-        const existingLoad = this.getProviderLoad(options.cwd, options.provider);
+        const existingLoad = this.getProviderLoad(options.snapshotCwd, options.provider);
         if (existingLoad && !options.force) {
             return existingLoad.promise;
         }
-        const existingEntry = this.snapshots.get(options.cwd)?.get(options.provider);
+        const existingEntry = this.snapshots.get(options.snapshotCwd)?.get(options.provider);
         if (existingEntry && existingEntry.status !== "loading" && !options.force) {
             return Promise.resolve();
         }
         const load = {
             promise: Promise.resolve(),
         };
-        this.setProviderLoad(options.cwd, options.provider, load);
+        this.setProviderLoad(options.snapshotCwd, options.provider, load);
         load.promise = Promise.resolve()
             .then(() => this.refreshProvider({
-            cwd: options.cwd,
+            snapshotCwd: options.snapshotCwd,
+            catalogScope: options.catalogScope,
             provider: options.provider,
             definition,
             load,
             force: options.force,
         }))
             .finally(() => {
-            const providerLoads = this.providerLoads.get(options.cwd);
+            const providerLoads = this.providerLoads.get(options.snapshotCwd);
             if (providerLoads?.get(options.provider) === load) {
                 providerLoads.delete(options.provider);
             }
             if (providerLoads?.size === 0) {
-                this.providerLoads.delete(options.cwd);
+                this.providerLoads.delete(options.snapshotCwd);
             }
         });
         return load.promise;
     }
     async refreshProvider(options) {
-        const { cwd, provider, definition, load, force } = options;
-        const snapshot = this.getOrCreateSnapshot(options.cwd);
+        const { snapshotCwd, catalogScope, provider, definition, load, force } = options;
+        const snapshot = this.getOrCreateSnapshot(snapshotCwd);
         const base = {
             provider,
             label: definition.label,
@@ -436,11 +497,11 @@ export class ProviderSnapshotManager {
             defaultModeId: definition.defaultModeId,
         };
         const setEntry = (entry) => {
-            if (!this.isCurrentProviderLoad(cwd, provider, load)) {
+            if (!this.isCurrentProviderLoad(snapshotCwd, provider, load)) {
                 return false;
             }
             snapshot.set(provider, entry);
-            this.emitChange(cwd);
+            this.emitChange(snapshotCwd);
             return true;
         };
         try {
@@ -454,7 +515,8 @@ export class ProviderSnapshotManager {
                 setEntry({ ...base, status: "unavailable", enabled: true });
                 return;
             }
-            const catalog = await withTimeout(definition.fetchCatalog({ cwd, force }, client), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
+            const catalogOptions = createFetchCatalogOptions(catalogScope, force);
+            const catalog = await withTimeout(definition.fetchCatalog({ ...catalogOptions, timeoutMs: this.refreshTimeoutMs }, client), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
             setEntry({
                 ...base,
                 status: "ready",
@@ -472,7 +534,7 @@ export class ProviderSnapshotManager {
                 error: toErrorMessage(error),
             });
             if (emitted) {
-                this.logger.warn({ err: error, provider, cwd }, "Failed to refresh provider snapshot");
+                this.logger.warn({ err: error, provider, cwd: snapshotCwd }, "Failed to refresh provider snapshot");
             }
         }
     }
@@ -564,6 +626,34 @@ export function resolveSnapshotCwd(cwd) {
     }
     return resolved;
 }
+function resolveProviderSnapshotTarget(cwd) {
+    const trimmed = cwd?.trim();
+    if (!trimmed) {
+        return createGlobalSnapshotTarget();
+    }
+    return createWorkspaceSnapshotTarget(resolveSnapshotCwd(trimmed));
+}
+function createGlobalSnapshotTarget() {
+    return {
+        snapshotCwd: GLOBAL_PROVIDER_SNAPSHOT_KEY,
+        catalogScope: { scope: "global" },
+    };
+}
+function createWorkspaceSnapshotTarget(cwd) {
+    const snapshotCwd = resolveSnapshotCwd(cwd);
+    return {
+        snapshotCwd,
+        catalogScope: { scope: "workspace", cwd: snapshotCwd },
+    };
+}
+function createFetchCatalogOptions(scope, force) {
+    return scope.scope === "global"
+        ? { scope: "global", force }
+        : { scope: "workspace", cwd: scope.cwd, force };
+}
+export function isGlobalProviderSnapshotKey(cwd) {
+    return cwd === GLOBAL_PROVIDER_SNAPSHOT_KEY;
+}
 function entriesToArray(entries) {
     return Array.from(entries.values(), cloneEntry);
 }

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

@@ -5,6 +5,7 @@ import { ClientSideConnection, type Client as ACPClient, type CreateTerminalRequ
 import type { Logger } from "pino";
 import { type AgentCapabilityFlags, type AgentClient, type AgentFeature, 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 FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../agent-sdk-types.js";
 import { type ProviderRuntimeSettings } from "../provider-launch-config.js";
+import { type DiagnosticEntry } from "./diagnostic-utils.js";
 export declare function summarizeACPRequestError(error: unknown): {
     message: string;
     code?: string;
@@ -62,6 +63,17 @@ export interface SpawnedACPProcess {
     child: ChildProcessWithoutNullStreams;
     connection: ClientSideConnection;
     initialize: InitializeResponse;
+    stderrChunks?: string[];
+}
+type UninitializedACPProcess = Omit<SpawnedACPProcess, "initialize"> & {
+    initialize?: InitializeResponse;
+};
+interface ACPProcessTransport {
+    child: ChildProcessWithoutNullStreams;
+    connection: ClientSideConnection;
+    stderrChunks: string[];
+    spawnReady: Promise<void>;
+    spawnError: Promise<never>;
 }
 export interface ACPToolSnapshot {
     toolCallId: string;
@@ -176,10 +188,17 @@ export declare class ACPAgentClient implements AgentClient {
     isAvailable(): Promise<boolean>;
     protected spawnProcess(launchEnv?: Record<string, string>, options?: {
         initializeTimeoutMs?: number;
+        onSpawned?: (probe: UninitializedACPProcess) => void;
     }): Promise<SpawnedACPProcess>;
+    protected spawnTransport(launchEnv?: Record<string, string>): Promise<ACPProcessTransport>;
+    protected initializeTransport(transport: ACPProcessTransport, initializeTimeoutMs?: number): Promise<InitializeResponse>;
     protected buildProbeClient(): ACPClient;
-    protected closeProbe(probe: SpawnedACPProcess): Promise<void>;
+    protected closeProbe(probe: UninitializedACPProcess): Promise<void>;
     protected runACPRequest<T>(request: () => Promise<T>): Promise<T>;
+    protected buildACPProbeDiagnosticRows(options?: {
+        cwd?: string;
+        phaseTimeoutMs?: number;
+    }): Promise<DiagnosticEntry[]>;
     protected resolveLaunchCommand(): Promise<{
         command: string;
         args: string[];
@@ -242,6 +261,13 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     constructor(config: AgentSessionConfig, options: ACPAgentSessionOptions);
     get id(): string | null;
     initializeNewSession(): Promise<void>;
+    /**
+     * IMPORTANT: Some ACP providers (e.g., Devin CLI) require all three params
+     * (sessionId, cwd, mcpServers) to be present in session/load or
+     * unstable_resumeSession — even when mcpServers is an empty array — and
+     * return "Invalid params" if any are omitted. Never drop cwd or mcpServers
+     * from these calls regardless of capabilities.
+     */
     initializeResumedSession(): Promise<void>;
     run(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<AgentRunResult>;
     startTurn(prompt: AgentPromptInput, options?: AgentRunOptions): Promise<{