@getpaseo/server 0.1.82 → 0.1.84

package/dist/server/server/agent/provider-launch-config.js

@@ -1,86 +1,79 @@
-import { z } from "zod";
-import { execFileSync } from "node:child_process";
-import path from "node:path";
-import { isCommandAvailable } from "../../utils/executable.js";
+import { isAbsolute } from "node:path";
+import { executableExists, findExecutable } from "../../utils/executable.js";
 import { createExternalProcessEnv } from "../paseo-env.js";
-import { AgentProviderSchema } from "./provider-manifest.js";
-const ProviderCommandDefaultSchema = z
-    .object({
-    mode: z.literal("default"),
-})
-    .strict();
-const ProviderCommandAppendSchema = z
-    .object({
-    mode: z.literal("append"),
-    args: z.array(z.string()).optional(),
-})
-    .strict();
-const ProviderCommandReplaceSchema = z
-    .object({
-    mode: z.literal("replace"),
-    argv: z.array(z.string().min(1)).min(1),
-})
-    .strict();
-export const ProviderCommandSchema = z.discriminatedUnion("mode", [
-    ProviderCommandDefaultSchema,
-    ProviderCommandAppendSchema,
-    ProviderCommandReplaceSchema,
-]);
-export const ProviderRuntimeSettingsSchema = z
-    .object({
-    command: ProviderCommandSchema.optional(),
-    env: z.record(z.string()).optional(),
-    disallowedTools: z.array(z.string()).optional(),
-})
-    .strict();
-const ProviderProfileThinkingOptionSchema = z
-    .object({
-    id: z.string(),
-    label: z.string(),
-    description: z.string().optional(),
-    isDefault: z.boolean().optional(),
-})
-    .strict();
-export const ProviderProfileModelSchema = z
-    .object({
-    id: z.string().min(1),
-    label: z.string().min(1),
-    description: z.string().optional(),
-    isDefault: z.boolean().optional(),
-    thinkingOptions: z.array(ProviderProfileThinkingOptionSchema).optional(),
-})
-    .strict();
-export const ProviderOverrideSchema = z
-    .object({
-    extends: z.string().optional(),
-    label: z.string().optional(),
-    description: z.string().optional(),
-    command: z.array(z.string().min(1)).min(1).optional(),
-    env: z.record(z.string()).optional(),
-    models: z.array(ProviderProfileModelSchema).optional(),
-    additionalModels: z.array(ProviderProfileModelSchema).optional(),
-    disallowedTools: z.array(z.string()).optional(),
-    enabled: z.boolean().optional(),
-    order: z.number().optional(),
-})
-    .strict();
-export const AgentProviderRuntimeSettingsMapSchema = z.record(AgentProviderSchema, ProviderRuntimeSettingsSchema);
-export async function resolveProviderCommandPrefix(commandConfig, resolveDefaultCommand) {
-    if (!commandConfig || commandConfig.mode === "default") {
+export { AgentProviderRuntimeSettingsMapSchema, ProviderCommandSchema, ProviderOverrideSchema, ProviderOverridesSchema, ProviderProfileModelSchema, ProviderRuntimeSettingsSchema, } from "@getpaseo/protocol/provider-config";
+import { ProviderOverrideSchema, ProviderOverridesSchema, ProviderRuntimeSettingsSchema, } from "@getpaseo/protocol/provider-config";
+function normalizeLaunchDefault(defaultBinary) {
+    if (typeof defaultBinary === "string") {
+        return { command: defaultBinary };
+    }
+    return defaultBinary;
+}
+async function resolveLaunchPath(command) {
+    const found = await findExecutable(command);
+    if (found) {
+        return found;
+    }
+    if (isAbsolute(command)) {
+        return executableExists(command);
+    }
+    return null;
+}
+async function resolveDefaultLaunchPath(defaultBinary) {
+    return defaultBinary.resolvePath
+        ? await defaultBinary.resolvePath()
+        : await resolveLaunchPath(defaultBinary.command);
+}
+export async function resolveProviderLaunch({ commandConfig, defaultBinary, }) {
+    if (commandConfig?.mode === "replace") {
+        const command = commandConfig.argv[0];
         return {
-            command: await resolveDefaultCommand(),
-            args: [],
+            command,
+            args: commandConfig.argv.slice(1),
+            source: "override",
         };
     }
-    if (commandConfig.mode === "append") {
+    if (defaultBinary === undefined) {
+        throw new Error("defaultBinary is required when provider command is not replaced");
+    }
+    const normalizedDefault = normalizeLaunchDefault(defaultBinary);
+    const args = commandConfig?.mode === "append" ? [...(commandConfig.args ?? [])] : [];
+    return {
+        command: normalizedDefault.command,
+        args,
+        source: commandConfig?.mode === "append" ? "append" : "default",
+    };
+}
+export async function checkProviderLaunchAvailable(launch, defaultBinary) {
+    const resolvedPath = defaultBinary && launch.source !== "override"
+        ? await resolveDefaultLaunchPath(defaultBinary)
+        : await resolveLaunchPath(launch.command);
+    return {
+        available: resolvedPath !== null,
+        resolvedPath,
+    };
+}
+export async function resolveProviderCommandPrefix(commandConfig, resolveDefaultCommand) {
+    if (commandConfig?.mode === "replace") {
+        const launch = await resolveProviderLaunch({
+            commandConfig,
+        });
         return {
-            command: await resolveDefaultCommand(),
-            args: [...(commandConfig.args ?? [])],
+            command: launch.command,
+            args: launch.args,
         };
     }
+    const defaultCommand = await resolveDefaultCommand();
+    const launch = await resolveProviderLaunch({
+        commandConfig,
+        defaultBinary: {
+            command: defaultCommand,
+            resolvePath: async () => defaultCommand,
+        },
+    });
     return {
-        command: commandConfig.argv[0],
-        args: commandConfig.argv.slice(1),
+        command: launch.command,
+        args: launch.args,
     };
 }
 let cachedShellEnv = null;
@@ -120,7 +113,7 @@ export function migrateProviderSettings(raw, builtinProviderIds) {
         }
         migrated[providerId] = nextEntry;
     }
-    return migrated;
+    return ProviderOverridesSchema.parse(migrated);
 }
 // Env vars that indicate a running Claude Code session. If the daemon itself is
 // launched from inside Claude Code (e.g. by a Paseo agent), these leak into
@@ -149,38 +142,23 @@ export function createProviderEnv(options = {}) {
     const spec = createProviderEnvSpec(options);
     return createExternalProcessEnv(spec.baseEnv ?? process.env, spec.envOverlay);
 }
-export function findExecutable(name) {
-    const trimmed = name.trim();
-    if (!trimmed)
-        return null;
-    if (trimmed.includes("/") || trimmed.includes("\\")) {
-        try {
-            const { existsSync } = require("node:fs");
-            return existsSync(trimmed) ? trimmed : null;
-        }
-        catch {
-            return null;
-        }
-    }
-    try {
-        const cmd = process.platform === "win32" ? "where.exe" : "which";
-        const result = execFileSync(cmd, [trimmed], {
-            encoding: "utf8",
-            env: createProviderEnv({ baseEnv: process.env }),
-            windowsHide: true,
-        }).trim();
-        const lines = result.split(/\r?\n/).filter((l) => l.trim());
-        const candidate = lines.at(-1)?.trim() ?? null;
-        return candidate && path.isAbsolute(candidate) ? candidate : null;
-    }
-    catch {
-        return null;
-    }
-}
 export async function isProviderCommandAvailable(commandConfig, resolveDefaultCommand) {
     try {
-        const prefix = await resolveProviderCommandPrefix(commandConfig, resolveDefaultCommand);
-        return isCommandAvailable(prefix.command);
+        if (commandConfig?.mode === "replace") {
+            const launch = await resolveProviderLaunch({
+                commandConfig,
+            });
+            const availability = await checkProviderLaunchAvailable(launch);
+            return availability.available;
+        }
+        const defaultCommand = await resolveDefaultCommand();
+        const defaultBinary = {
+            command: defaultCommand,
+            resolvePath: async () => defaultCommand,
+        };
+        const launch = await resolveProviderLaunch({ commandConfig, defaultBinary });
+        const availability = await checkProviderLaunchAvailable(launch, defaultBinary);
+        return availability.available;
     }
     catch {
         return false;

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

@@ -1,8 +1,8 @@
 import type { Logger } from "pino";
-import type { AgentClient, AgentMode, AgentModelDefinition, AgentProvider, AgentSession, ListModelsOptions, ListModesOptions } from "./agent-sdk-types.js";
+import type { AgentClient, AgentCreateConfigUnattendedInput, AgentMode, AgentModelDefinition, AgentProvider, AgentSession, ListModelsOptions, ListModesOptions, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
 import type { WorkspaceGitService } from "../workspace-git-service.js";
 import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./provider-launch-config.js";
-import { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition, type AgentProviderDefinition } from "./provider-manifest.js";
+import { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition, type AgentProviderDefinition } from "@getpaseo/protocol/provider-manifest";
 export type { AgentProviderDefinition };
 export { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition };
 export interface ProviderDefinition extends AgentProviderDefinition {
@@ -14,10 +14,12 @@ export interface ProviderDefinition extends AgentProviderDefinition {
      */
     derivedFromProviderId: string | null;
     createClient: (logger: Logger) => AgentClient;
+    resolveCreateConfig: (input: ResolveAgentCreateConfigInput) => ResolveAgentCreateConfigResult;
+    isCreateConfigUnattended: (input: AgentCreateConfigUnattendedInput) => boolean;
     fetchModels: (options: ListModelsOptions) => Promise<AgentModelDefinition[]>;
     fetchModes: (options: ListModesOptions) => Promise<AgentMode[]>;
 }
-export { IMPORTABLE_PROVIDERS } from "../../shared/importable-providers.js";
+export { IMPORTABLE_PROVIDERS } from "@getpaseo/protocol/importable-providers";
 export interface BuildProviderRegistryOptions {
     runtimeSettings?: AgentProviderRuntimeSettingsMap;
     providerOverrides?: Record<string, ProviderOverride>;
@@ -31,4 +33,5 @@ export declare const PROVIDER_REGISTRY: Record<AgentProvider, ProviderDefinition
 export declare function createAllClients(logger: Logger, options?: BuildProviderRegistryOptions): Record<AgentProvider, AgentClient>;
 export declare function createClientsFromRegistry(registry: Record<AgentProvider, ProviderDefinition>, logger: Logger): Record<AgentProvider, AgentClient>;
 export declare function shutdownProviders(logger: Logger, options?: BuildProviderRegistryOptions): Promise<void>;
+export declare function shutdownAgentClients(clients: Iterable<AgentClient>, logger: Logger): Promise<void>;
 //# sourceMappingURL=provider-registry.d.ts.map

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

@@ -1,3 +1,4 @@
+import { isDefaultAgentCreateConfigUnattended, resolveDefaultAgentCreateConfig, } from "./create-agent-mode.js";
 import { normalizeAgentModelDefinition } from "./agent-sdk-types.js";
 import { ClaudeAgentClient } from "./providers/claude/agent.js";
 import { CodexAppServerAgentClient } from "./providers/codex-app-server-agent.js";
@@ -5,15 +6,15 @@ import { CopilotACPAgentClient } from "./providers/copilot-acp-agent.js";
 import { CursorACPAgentClient } from "./providers/cursor-acp-agent.js";
 import { GenericACPAgentClient } from "./providers/generic-acp-agent.js";
 import { OpenCodeAgentClient } from "./providers/opencode-agent.js";
-import { OpenCodeServerManager } from "./providers/opencode/server-manager.js";
 import { PiRpcAgentClient } from "./providers/pi/agent.js";
 import { MockLoadTestAgentClient } from "./providers/mock-load-test-agent.js";
-import { AGENT_PROVIDER_DEFINITIONS, BUILTIN_PROVIDER_IDS, DEV_AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition, } from "./provider-manifest.js";
+import { MockSlowProviderClient } from "./providers/mock-slow-provider.js";
+import { AGENT_PROVIDER_DEFINITIONS, BUILTIN_PROVIDER_IDS, DEV_AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition, } from "@getpaseo/protocol/provider-manifest";
 function isNonEmptyStringArray(value) {
     return value.length > 0;
 }
 export { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition };
-export { IMPORTABLE_PROVIDERS } from "../../shared/importable-providers.js";
+export { IMPORTABLE_PROVIDERS } from "@getpaseo/protocol/importable-providers";
 const PROVIDER_CLIENT_FACTORIES = {
     claude: (logger, runtimeSettings) => new ClaudeAgentClient({
         logger,
@@ -38,6 +39,7 @@ const PROVIDER_CLIENT_FACTORIES = {
         runtimeSettings,
     }),
     mock: (logger) => new MockLoadTestAgentClient(logger),
+    "mock-slow": () => new MockSlowProviderClient(),
 };
 function getCursorACPCommand(runtimeSettings) {
     if (runtimeSettings?.command?.mode === "replace" &&
@@ -229,6 +231,8 @@ function wrapClientProvider(provider, inner, profileModels, additionalModels, pr
             profileModelsAreAdditive,
         }),
         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))
             : undefined,
@@ -243,6 +247,8 @@ function createRegistryEntry(logger, provider, resolved) {
         enabled: resolved.enabled,
         derivedFromProviderId: resolved.derivedFromProviderId,
         createClient: (providerLogger) => createResolvedProviderClient(providerLogger, provider, resolved),
+        resolveCreateConfig: modelClient.resolveCreateConfig ?? resolveDefaultAgentCreateConfig,
+        isCreateConfigUnattended: modelClient.isCreateConfigUnattended ?? isDefaultAgentCreateConfigUnattended,
         fetchModels: async (options) => mergeModels(provider, resolved.profileModels, resolved.additionalModels, await modelClient.listModels(options), {
             profileModelsAreAdditive: resolved.profileModelsAreAdditive,
         }),
@@ -395,6 +401,19 @@ export function createClientsFromRegistry(registry, logger) {
     ]));
 }
 export async function shutdownProviders(logger, options) {
-    await OpenCodeServerManager.getInstance(logger, options?.runtimeSettings?.opencode).shutdown();
+    const clients = createAllClients(logger, options);
+    await shutdownAgentClients(Object.values(clients), logger);
+}
+export async function shutdownAgentClients(clients, logger) {
+    await Promise.all(Array.from(clients).map(async (client) => {
+        if (!client.shutdown)
+            return;
+        try {
+            await client.shutdown();
+        }
+        catch (error) {
+            logger.warn({ err: error, provider: client.provider }, "Provider client shutdown failed");
+        }
+    }));
 }
 //# sourceMappingURL=provider-registry.js.map

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

@@ -1,32 +1,102 @@
 import type { Logger } from "pino";
-import type { AgentProvider, ProviderSnapshotEntry } from "./agent-sdk-types.js";
-import type { ProviderDefinition } from "./provider-registry.js";
+import type { AgentClient, AgentMode, AgentModelDefinition, AgentProvider, ProviderSnapshotEntry } from "./agent-sdk-types.js";
+import type { ManagedAgent } from "./agent-manager.js";
+import type { WorkspaceGitService } from "../workspace-git-service.js";
+import type { AgentProviderRuntimeSettingsMap, ProviderOverride } from "./provider-launch-config.js";
+import type { MutableDaemonConfig } from "../daemon-config-store.js";
 type ProviderSnapshotChangeListener = (entries: ProviderSnapshotEntry[], cwd: string) => void;
-interface ProviderSnapshotManagerOptions {
+export interface ProviderSnapshotManagerOptions {
+    logger: Logger;
+    runtimeSettings?: AgentProviderRuntimeSettingsMap;
+    providerOverrides?: Record<string, ProviderOverride>;
+    workspaceGitService?: Pick<WorkspaceGitService, "resolveRepoRoot">;
+    isDev?: boolean;
+    extraClients?: Partial<Record<AgentProvider, AgentClient>>;
     refreshTimeoutMs?: number;
 }
 interface ProviderSnapshotRefreshOptions {
     cwd: string;
     providers?: AgentProvider[];
 }
+interface ProviderSnapshotReadOptions {
+    cwd?: string | null;
+    providers?: AgentProvider[];
+    wait?: boolean;
+}
+interface ProviderSnapshotProviderOptions {
+    cwd?: string | null;
+    provider: AgentProvider;
+    wait?: boolean;
+}
+interface ResolveProviderCreateConfigOptions {
+    cwd?: string | null;
+    provider: AgentProvider;
+    requestedMode: string | undefined;
+    featureValues: Record<string, unknown> | undefined;
+    parent: ManagedAgent | null;
+}
+export interface ResolvedProviderCreateConfig {
+    modeId: string | undefined;
+    featureValues: Record<string, unknown> | undefined;
+}
+interface ResolveDefaultModelOptions {
+    provider: AgentProvider;
+    requestedModel?: string | null;
+    cwd?: string;
+}
+export interface ProviderDiagnosticResult {
+    provider: AgentProvider;
+    diagnostic: string;
+}
+export interface AgentManagerProviderState {
+    providerDefinitions: Partial<Record<AgentProvider, {
+        enabled: boolean;
+        derivedFromProviderId: string | null;
+    }>>;
+    clients: Partial<Record<AgentProvider, AgentClient>>;
+}
 export declare class ProviderSnapshotManager {
-    private readonly logger;
     private readonly snapshots;
     private readonly providerLoads;
     private readonly events;
     private destroyed;
     private readonly refreshTimeoutMs;
+    private readonly logger;
+    private readonly workspaceGitService?;
+    private readonly isDev;
+    private readonly extraClients;
+    private runtimeSettings;
+    private providerOverrides;
+    private readonly baseProviderOverrides;
     private providerRegistry;
-    constructor(providerRegistry: Record<AgentProvider, ProviderDefinition>, logger: Logger, options?: ProviderSnapshotManagerOptions);
+    private providerClients;
+    constructor(options: ProviderSnapshotManagerOptions);
     getSnapshot(cwd?: string): ProviderSnapshotEntry[];
     refreshSnapshotForCwd(options: ProviderSnapshotRefreshOptions): Promise<void>;
     refreshSettingsSnapshot(options?: Omit<ProviderSnapshotRefreshOptions, "cwd">): Promise<void>;
     warmUpSnapshotForCwd(options: ProviderSnapshotRefreshOptions): Promise<void>;
     refresh(options: ProviderSnapshotRefreshOptions): Promise<void>;
+    listRegisteredProviderIds(): AgentProvider[];
+    hasProvider(provider: AgentProvider): boolean;
+    getProviderLabel(provider: AgentProvider): string;
+    getAgentManagerProviderState(): AgentManagerProviderState;
+    private ensureClient;
+    listProviders(input?: ProviderSnapshotReadOptions): Promise<ProviderSnapshotEntry[]>;
+    getProvider(input: ProviderSnapshotProviderOptions): Promise<ProviderSnapshotEntry>;
+    listModels(input: ProviderSnapshotProviderOptions): Promise<AgentModelDefinition[]>;
+    listModes(input: ProviderSnapshotProviderOptions): Promise<AgentMode[]>;
+    resolveDefaultModel(input: ResolveDefaultModelOptions): Promise<string | undefined>;
+    resolveCreateConfig(input: ResolveProviderCreateConfigOptions): Promise<ResolvedProviderCreateConfig>;
+    getProviderDiagnostic(provider: AgentProvider): Promise<ProviderDiagnosticResult>;
+    applyMutableProviderConfig(mutableProviders: MutableDaemonConfig["providers"] | undefined): AgentManagerProviderState;
     on(event: "change", listener: ProviderSnapshotChangeListener): this;
     off(event: "change", listener: ProviderSnapshotChangeListener): this;
+    shutdown(): Promise<void>;
     destroy(): void;
-    replaceRegistry(providerRegistry: Record<AgentProvider, ProviderDefinition>): void;
+    private buildRegistry;
+    private resolveParent;
+    private getReadyProvider;
+    private requireProvider;
     private createLoadingEntries;
     private reconcileSnapshotForRegistry;
     private warmUp;

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

@@ -1,17 +1,27 @@
 import { EventEmitter } from "node:events";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
+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";
 const DEFAULT_REFRESH_TIMEOUT_MS = 30000;
 export class ProviderSnapshotManager {
-    constructor(providerRegistry, logger, options = {}) {
-        this.logger = logger;
+    constructor(options) {
         this.snapshots = new Map();
         this.providerLoads = new Map();
         this.events = new EventEmitter();
         this.destroyed = false;
-        this.providerRegistry = providerRegistry;
+        this.logger = options.logger;
+        this.workspaceGitService = options.workspaceGitService;
+        this.isDev = options.isDev === true;
+        this.extraClients = options.extraClients ?? {};
+        this.runtimeSettings = options.runtimeSettings;
+        this.providerOverrides = options.providerOverrides;
+        this.baseProviderOverrides = options.providerOverrides;
         this.refreshTimeoutMs = options.refreshTimeoutMs ?? DEFAULT_REFRESH_TIMEOUT_MS;
+        this.providerRegistry = this.buildRegistry();
+        this.providerClients = { ...this.extraClients };
     }
     getSnapshot(cwd) {
         const resolvedCwd = resolveSnapshotCwd(cwd);
@@ -78,6 +88,122 @@ export class ProviderSnapshotManager {
     async refresh(options) {
         await this.refreshSnapshotForCwd(options);
     }
+    listRegisteredProviderIds() {
+        return this.getProviderIds();
+    }
+    hasProvider(provider) {
+        return Object.prototype.hasOwnProperty.call(this.providerRegistry, provider);
+    }
+    getProviderLabel(provider) {
+        return this.providerRegistry[provider]?.label ?? provider;
+    }
+    getAgentManagerProviderState() {
+        const providerDefinitions = {};
+        const clients = {};
+        for (const [provider, definition] of Object.entries(this.providerRegistry)) {
+            providerDefinitions[provider] = {
+                enabled: definition.enabled,
+                derivedFromProviderId: definition.derivedFromProviderId,
+            };
+            if (definition.enabled) {
+                clients[provider] = this.ensureClient(provider, definition);
+            }
+        }
+        for (const [provider, client] of Object.entries(this.extraClients)) {
+            if (client) {
+                clients[provider] = client;
+            }
+        }
+        return { providerDefinitions, clients };
+    }
+    ensureClient(provider, definition) {
+        const existing = this.providerClients[provider];
+        if (existing) {
+            return existing;
+        }
+        const client = definition.createClient(this.logger);
+        this.providerClients[provider] = client;
+        return client;
+    }
+    async listProviders(input = {}) {
+        const cwd = resolveSnapshotCwd(input.cwd);
+        if (input.wait) {
+            await this.warmUpSnapshotForCwd({ cwd, providers: input.providers });
+        }
+        const providerFilter = input.providers ? new Set(input.providers) : null;
+        const entries = this.getSnapshot(cwd);
+        return providerFilter ? entries.filter((entry) => providerFilter.has(entry.provider)) : entries;
+    }
+    async getProvider(input) {
+        const entry = (await this.listProviders({ ...input, providers: [input.provider] })).find((candidate) => candidate.provider === input.provider);
+        if (!entry) {
+            throw new Error(`Provider ${input.provider} is not configured`);
+        }
+        return entry;
+    }
+    async listModels(input) {
+        const entry = await this.getReadyProvider(input);
+        return entry.models ?? [];
+    }
+    async listModes(input) {
+        const entry = await this.getReadyProvider(input);
+        return entry.modes ?? [];
+    }
+    async resolveDefaultModel(input) {
+        try {
+            const trimmed = input.requestedModel?.trim();
+            if (trimmed) {
+                return trimmed;
+            }
+            const models = await this.listModels({
+                provider: input.provider,
+                cwd: input.cwd ? expandTilde(input.cwd) : undefined,
+                wait: true,
+            });
+            const preferred = models.find((model) => model.isDefault) ?? models[0];
+            return preferred?.id;
+        }
+        catch (error) {
+            this.logger.warn({ err: error, provider: input.provider }, "Failed to resolve default model");
+            return undefined;
+        }
+    }
+    async resolveCreateConfig(input) {
+        const entry = await this.getReadyProvider({
+            cwd: input.cwd,
+            provider: input.provider,
+            wait: true,
+        });
+        const definition = this.requireProvider(input.provider);
+        return definition.resolveCreateConfig({
+            provider: input.provider,
+            requestedMode: input.requestedMode,
+            featureValues: input.featureValues,
+            parent: input.parent ? this.resolveParent(input.parent) : null,
+            availableModes: entry.modes ?? [],
+        });
+    }
+    async getProviderDiagnostic(provider) {
+        const client = this.providerClients[provider];
+        if (!client) {
+            throw new Error(`Provider ${provider} is not configured`);
+        }
+        const diagnostic = client.getDiagnostic
+            ? (await client.getDiagnostic()).diagnostic
+            : "No diagnostic available for this provider.";
+        return { provider, diagnostic };
+    }
+    applyMutableProviderConfig(mutableProviders) {
+        this.providerOverrides = applyMutableProviderConfigToOverrides(this.baseProviderOverrides, mutableProviders);
+        this.providerRegistry = this.buildRegistry();
+        this.providerClients = { ...this.extraClients };
+        for (const cwd of this.snapshots.keys()) {
+            this.providerLoads.delete(cwd);
+            this.snapshots.set(cwd, this.reconcileSnapshotForRegistry(cwd));
+            this.emitChange(cwd);
+        }
+        return this.getAgentManagerProviderState();
+    }
     on(event, listener) {
         this.events.on(event, listener);
         return this;
@@ -86,19 +212,60 @@ export class ProviderSnapshotManager {
         this.events.off(event, listener);
         return this;
     }
+    async shutdown() {
+        // Materialize a client per enabled provider so provider-owned resources
+        // (background processes, sockets, etc.) get a chance to release even when
+        // a given provider hasn't been touched yet during this daemon's lifetime.
+        const state = this.getAgentManagerProviderState();
+        const clients = Object.values(state.clients).filter((client) => client !== undefined);
+        await shutdownAgentClients(clients, this.logger);
+    }
     destroy() {
         this.destroyed = true;
         this.events.removeAllListeners();
         this.snapshots.clear();
         this.providerLoads.clear();
     }
-    replaceRegistry(providerRegistry) {
-        this.providerRegistry = providerRegistry;
-        for (const cwd of this.snapshots.keys()) {
-            this.providerLoads.delete(cwd);
-            this.snapshots.set(cwd, this.reconcileSnapshotForRegistry(cwd));
-            this.emitChange(cwd);
+    buildRegistry() {
+        return buildProviderRegistry(this.logger, {
+            runtimeSettings: this.runtimeSettings,
+            providerOverrides: this.providerOverrides,
+            workspaceGitService: this.workspaceGitService,
+            isDev: this.isDev,
+        });
+    }
+    resolveParent(parent) {
+        const definition = this.requireProvider(parent.provider);
+        return {
+            provider: parent.provider,
+            modeId: parent.currentModeId,
+            isUnattended: definition.isCreateConfigUnattended({
+                modeId: parent.currentModeId,
+                config: parent.config,
+                features: parent.features,
+                availableModes: parent.availableModes ?? definition.modes ?? [],
+            }),
+        };
+    }
+    async getReadyProvider(input) {
+        const entry = await this.getProvider(input);
+        if (!entry.enabled) {
+            throw new Error(`Provider '${entry.provider}' is disabled`);
+        }
+        if (entry.status === "ready") {
+            return entry;
+        }
+        if (entry.status === "error") {
+            throw new Error(entry.error ?? `Failed to load provider '${entry.provider}'`);
+        }
+        throw new Error(`Provider '${entry.provider}' is not available`);
+    }
+    requireProvider(provider) {
+        const definition = this.providerRegistry[provider];
+        if (!definition) {
+            throw new Error(`Provider ${provider} is not configured`);
         }
+        return definition;
     }
     createLoadingEntries() {
         const entries = new Map();
@@ -248,7 +415,7 @@ export class ProviderSnapshotManager {
                 setEntry({ ...base, status: "unavailable", enabled: false });
                 return;
             }
-            const client = definition.createClient(this.logger);
+            const client = this.ensureClient(provider, definition);
             const available = await withTimeout(client.isAvailable(), this.refreshTimeoutMs, `Timed out checking ${definition.label} availability after ${this.refreshTimeoutMs}ms`);
             if (!available) {
                 setEntry({ ...base, status: "unavailable", enabled: true });