@getpaseo/server 0.1.99 → 0.1.101

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-registry.js

@@ -51,6 +51,7 @@ const PROVIDER_CLIENT_FACTORIES = {
         providerParams: options?.providerParams ?? {
             sessionDir: "~/.omp/agent/sessions",
         },
+        commandsRpcType: "get_available_commands",
     }),
     mock: (logger) => new MockLoadTestAgentClient(logger),
     "mock-slow": () => new MockSlowProviderClient(),

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

@@ -15,6 +15,7 @@ export interface ProviderSnapshotManagerOptions {
     isDev?: boolean;
     extraClients?: Partial<Record<AgentProvider, AgentClient>>;
     refreshTimeoutMs?: number;
+    diagnosticTimeoutMs?: number;
 }
 interface ProviderSnapshotRefreshOptions {
     cwd: string;
@@ -64,6 +65,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?;
@@ -101,6 +103,8 @@ export declare class ProviderSnapshotManager {
     private resolveParent;
     private getReadyProvider;
     private requireProvider;
+    private refreshDiagnosticSnapshotEntry;
+    private getBaseProviderDiagnostic;
     private createLoadingEntries;
     private reconcileSnapshotForRegistry;
     private warmUp;

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

@@ -5,8 +5,9 @@ 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";
 // Provider refresh probes can be slow on cold starts (e.g. Copilot's first
 // `copilot --acp` invocation, OpenCode workspace probes with many MCP servers).
@@ -25,6 +26,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,6 +47,7 @@ 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 };
     }
@@ -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 };
     }
@@ -283,6 +296,38 @@ export class ProviderSnapshotManager {
         }
         return definition;
     }
+    async refreshDiagnosticSnapshotEntry(provider, definition) {
+        try {
+            const cwd = resolveSnapshotCwd();
+            await this.refreshSnapshotForCwd({ cwd, providers: [provider] });
+            return await this.getProvider({ cwd, 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()) {
@@ -454,7 +499,7 @@ 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 catalog = await withTimeout(definition.fetchCatalog({ cwd, force, timeoutMs: this.refreshTimeoutMs }, client), this.refreshTimeoutMs, `Timed out refreshing ${definition.label} after ${this.refreshTimeoutMs}ms`);
             setEntry({
                 ...base,
                 status: "ready",

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

@@ -3,8 +3,9 @@ import type { ProcessTerminator } from "../../../utils/tree-kill.js";
 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 FetchCatalogOptions, type ImportableProviderSession, type ImportProviderSessionContext, type ImportProviderSessionInput, type ListImportableSessionsOptions, type ProviderCatalog } from "../agent-sdk-types.js";
+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;
@@ -24,6 +25,7 @@ interface ACPAgentClientOptions {
     modelTransformer?: (models: AgentModelDefinition[]) => AgentModelDefinition[];
     sessionResponseTransformer?: (response: SessionStateResponse) => SessionStateResponse;
     configOptionsTransformer?: (configOptions: SessionConfigOption[]) => SessionConfigOption[];
+    configFeatureOptions?: ACPConfigFeatureOption[];
     modeIdTransformer?: (modeId: string) => string | null;
     toolSnapshotTransformer?: (snapshot: ACPToolSnapshot) => ACPToolSnapshot;
     providerModeWriter?: (context: ACPProviderModeWriterContext) => Promise<ACPProviderModeWriteResult>;
@@ -43,6 +45,7 @@ interface ACPAgentSessionOptions {
     modelTransformer?: (models: AgentModelDefinition[]) => AgentModelDefinition[];
     sessionResponseTransformer?: (response: SessionStateResponse) => SessionStateResponse;
     configOptionsTransformer?: (configOptions: SessionConfigOption[]) => SessionConfigOption[];
+    configFeatureOptions?: ACPConfigFeatureOption[];
     modeIdTransformer?: (modeId: string) => string | null;
     toolSnapshotTransformer?: (snapshot: ACPToolSnapshot) => ACPToolSnapshot;
     providerModeWriter?: (context: ACPProviderModeWriterContext) => Promise<ACPProviderModeWriteResult>;
@@ -60,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;
@@ -76,6 +90,16 @@ interface TerminalExit {
     exitCode?: number | null;
     signal?: string | null;
 }
+export interface ACPConfigFeatureOption {
+    id: string;
+    configId: string;
+    category: string;
+    label: string;
+    description?: string;
+    tooltip?: string;
+    icon?: string;
+    emptyOptionLabel?: string;
+}
 type SelectConfigOption = Extract<SessionConfigOption, {
     type: "select";
 }>;
@@ -134,6 +158,7 @@ export declare function deriveModesFromACP(fallbackModes: AgentMode[], modeState
     currentModeId: string | null;
 };
 export declare function deriveModelDefinitionsFromACP(provider: string, models: SessionModelState | null | undefined, configOptions?: SessionConfigOption[] | null): AgentModelDefinition[];
+export declare function deriveFeaturesFromACP(configOptions: SessionConfigOption[] | null | undefined, featureOptions: ACPConfigFeatureOption[]): AgentFeature[];
 export declare class ACPAgentClient implements AgentClient {
     readonly provider: string;
     readonly capabilities: AgentCapabilityFlags;
@@ -144,6 +169,7 @@ export declare class ACPAgentClient implements AgentClient {
     private readonly modelTransformer?;
     private readonly sessionResponseTransformer?;
     private readonly configOptionsTransformer?;
+    private readonly configFeatureOptions;
     private readonly modeIdTransformer?;
     private readonly toolSnapshotTransformer?;
     private readonly providerModeWriter?;
@@ -156,15 +182,23 @@ export declare class ACPAgentClient implements AgentClient {
     createSession(config: AgentSessionConfig, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     resumeSession(handle: AgentPersistenceHandle, overrides?: Partial<AgentSessionConfig>, launchContext?: AgentLaunchContext): Promise<AgentSession>;
     fetchCatalog(options: FetchCatalogOptions): Promise<ProviderCatalog>;
+    listFeatures(config: AgentSessionConfig): Promise<AgentFeature[]>;
     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;
+        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[];
@@ -182,6 +216,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     protected readonly modelTransformer?: (models: AgentModelDefinition[]) => AgentModelDefinition[];
     private readonly sessionResponseTransformer?;
     private readonly configOptionsTransformer?;
+    private readonly configFeatureOptions;
     private readonly modeIdTransformer?;
     private readonly toolSnapshotTransformer?;
     private readonly providerModeWriter?;
@@ -236,6 +271,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     getRuntimeInfo(): Promise<AgentRuntimeInfo>;
     getAvailableModes(): Promise<AgentMode[]>;
     getCurrentMode(): Promise<string | null>;
+    get features(): AgentFeature[];
     private ensureCommandsReadyDeferred;
     private settleCommandsReady;
     private waitForCommandsReady;
@@ -246,6 +282,7 @@ export declare class ACPAgentSession implements AgentSession, ACPClient {
     setModel(modelId: string | null): Promise<void>;
     private setModelWithSelection;
     setThinkingOption(thinkingOptionId: string | null): Promise<void>;
+    setFeature(featureId: string, value: unknown): Promise<void>;
     private applyConfigOptionResponse;
     getPendingPermissions(): AgentPermissionRequest[];
     respondToPermission(requestId: string, response: AgentPermissionResponse): Promise<void>;