@hyperdrive.bot/fleet-server 0.3.99

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

@@ -0,0 +1,686 @@
+import { execSync } from "node:child_process";
+import { createRequire } from "node:module";
+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";
+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 { KiroACPAgentClient } from "./providers/kiro-acp-agent.js";
+import { OpenCodeAgentClient } from "./providers/opencode-agent.js";
+import { PiRpcAgentClient } from "./providers/pi/agent.js";
+import { MockLoadTestAgentClient } from "./providers/mock-load-test-agent.js";
+import { MockSlowProviderClient } from "./providers/mock-slow-provider.js";
+import { AGENT_PROVIDER_DEFINITIONS, BUILTIN_PROVIDER_IDS, DEV_AGENT_PROVIDER_DEFINITIONS, computeEffectiveCompatibleProviders, getAgentProviderDefinition, } from "@hyperdrive.bot/fleet-protocol/provider-manifest";
+function isNonEmptyStringArray(value) {
+    return value.length > 0;
+}
+// Story 4.1 — Resolve the effective transport for the claude provider.
+// "sdk" and "pty" pass through unchanged. "auto" probes node-pty + the claude
+// binary; success → "pty", any failure → "sdk". Undefined (no config) → "auto"
+// (default flipped from "sdk" to "auto" after one-week PTY bake — Story 5.3).
+// node-pty is lazy-required so non-PTY users don't pay native-load cost.
+const requireFromHere = createRequire(import.meta.url);
+export function resolveClaudeTransport(setting, deps) {
+    if (setting === "sdk")
+        return "sdk";
+    if (setting === "pty")
+        return "pty";
+    const tryRequire = deps?.requireNodePty ?? (() => requireFromHere("node-pty"));
+    const tryProbe = deps?.probeClaudeBinary ?? (() => execSync("claude --version", { stdio: "pipe" }));
+    try {
+        tryRequire();
+        tryProbe();
+        return "pty";
+    }
+    catch {
+        return "sdk";
+    }
+}
+/**
+ * Internal agents (session-digest and auto-title generation) are headless,
+ * one-shot, `persistSession: false` runs. They have no TUI to drive: they are
+ * handed a prompt and asked for one structured answer.
+ *
+ * `resolveClaudeTransport` returns "pty" whenever node-pty and the `claude`
+ * binary are both present, which on a developer box is always, so these runs
+ * were being given a full interactive terminal and their prompt written through
+ * the PTY's bracketed-paste path. That path can refuse the write when the TUI
+ * is not in an input-accepting state, and the caller sees:
+ *
+ *   "Your message did not reach the agent: the terminal would not accept it."
+ *
+ * Measured on 2026-08-04: 187 of 191 structured-generation failures (98%) were
+ * exactly that error, across claude/pool/pool-tu and across haiku, opus-5 and
+ * opus-4-8, so it is neither provider- nor model-specific. Each failure burned
+ * a provider attempt until the digest's 120s budget expired, losing ~46% of all
+ * digests (116 DigestGenerationTimeoutError against 113 successful digests that
+ * day). Every lost digest also silently costs a Jarvis judgement, because the
+ * judge only wakes on the `onSettled` hook that a completed digest fires.
+ *
+ * Two cheaper explanations were tested and rejected before this one: prompt
+ * size (2 KB / 8 KB / 32 KB pastes all delivered fine) and a spawn/readiness
+ * race (three spawn-then-immediately-send probes all delivered fine).
+ *
+ * So internal agents default to the SDK transport, which needs no terminal. An
+ * EXPLICIT `transport` setting still wins: this only redirects the "auto" case,
+ * so anyone deliberately pinning "pty" keeps it.
+ */
+export function resolveInternalAgentTransportSetting(internal, setting) {
+    if (!internal)
+        return setting;
+    if (setting === "sdk" || setting === "pty")
+        return setting;
+    return "sdk";
+}
+export const NODE_PTY_UNAVAILABLE_REASON = "node-pty native module not built. Run 'npm rebuild node-pty' in packages/server.";
+export function isNodePtyAvailable(deps) {
+    const tryRequire = deps?.requireNodePty ?? (() => requireFromHere("node-pty"));
+    try {
+        tryRequire();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export { AGENT_PROVIDER_DEFINITIONS, getAgentProviderDefinition };
+const PROVIDER_CLIENT_FACTORIES = {
+    claude: (logger, runtimeSettings) => new ClaudeAgentClient({
+        logger,
+        runtimeSettings,
+    }),
+    codex: (logger, runtimeSettings, options) => new CodexAppServerAgentClient(logger, runtimeSettings, {
+        workspaceGitService: options?.workspaceGitService,
+        customProvider: options?.customProvider,
+    }),
+    copilot: (logger, runtimeSettings) => new CopilotACPAgentClient({
+        logger,
+        runtimeSettings,
+    }),
+    cursor: (logger, runtimeSettings) => new CursorACPAgentClient({
+        logger,
+        command: getCursorACPCommand(runtimeSettings),
+        env: runtimeSettings?.env,
+    }),
+    opencode: (logger, runtimeSettings, options) => new OpenCodeAgentClient(logger, runtimeSettings, {
+        managedProcesses: options?.managedProcesses,
+    }),
+    pi: (logger, runtimeSettings, options) => new PiRpcAgentClient({
+        logger,
+        runtimeSettings,
+        providerParams: options?.providerParams,
+    }),
+    omp: (logger, runtimeSettings, options) => new PiRpcAgentClient({
+        logger,
+        // OMP is backed by the Pi RPC adapter, which has no PTY/SDK transport
+        // concept (transport is claude-only). Upstream's generic
+        // mergeRuntimeSettings always injects a `transport` default ("auto"),
+        // so we strip it here to keep the Pi runtime-settings shape clean.
+        runtimeSettings: stripTransport(mergeRuntimeSettings({
+            command: {
+                mode: "replace",
+                argv: ["omp"],
+            },
+        }, runtimeSettings)),
+        providerParams: options?.providerParams ?? {
+            sessionDir: "~/.omp/agent/sessions",
+        },
+        commandsRpcType: "get_available_commands",
+    }),
+    mock: (logger) => new MockLoadTestAgentClient(logger),
+    "mock-slow": () => new MockSlowProviderClient(),
+};
+function getCursorACPCommand(runtimeSettings) {
+    if (runtimeSettings?.command?.mode === "replace" &&
+        isNonEmptyStringArray(runtimeSettings.command.argv)) {
+        return runtimeSettings.command.argv;
+    }
+    return ["cursor-agent", "acp"];
+}
+function getProviderClientFactory(provider) {
+    const factory = PROVIDER_CLIENT_FACTORIES[provider];
+    if (!factory) {
+        throw new Error(`No provider client factory registered for '${provider}'`);
+    }
+    return factory;
+}
+function toRuntimeSettings(override) {
+    if (!override?.command && !override?.env && !override?.disallowedTools && !override?.transport) {
+        return undefined;
+    }
+    return {
+        command: override.command
+            ? {
+                mode: "replace",
+                argv: override.command,
+            }
+            : undefined,
+        env: override.env,
+        disallowedTools: override.disallowedTools,
+        // Carry the configured transport through, and leave it undefined when the
+        // override does not set one. This field is the `override` side of
+        // mergeRuntimeSettings' `override?.transport ?? base?.transport ?? "auto"`,
+        // so hardcoding a value here silently wins over both the inherited base and
+        // the documented "auto" default: any provider that merely set `env` (every
+        // proxy-backed provider that extends claude) was pinned to "sdk" and could
+        // neither inherit a base opt-in nor honour its own configured transport.
+        transport: override.transport,
+    };
+}
+function mergeEnv(baseEnv, overrideEnv) {
+    if (!baseEnv && !overrideEnv) {
+        return undefined;
+    }
+    return { ...baseEnv, ...overrideEnv };
+}
+function mergeDisallowedTools(baseTools, overrideTools) {
+    if (!baseTools && !overrideTools) {
+        return undefined;
+    }
+    return [...(baseTools ?? []), ...(overrideTools ?? [])];
+}
+function mergeRuntimeSettings(base, override) {
+    if (!base && !override) {
+        return undefined;
+    }
+    return {
+        command: override?.command ?? base?.command,
+        env: mergeEnv(base?.env, override?.env),
+        disallowedTools: mergeDisallowedTools(base?.disallowedTools, override?.disallowedTools),
+        transport: override?.transport ?? base?.transport ?? "auto",
+    };
+}
+// Pi-backed providers (e.g. OMP) do not use the claude-only `transport`
+// field. Drop it so their runtime-settings shape stays minimal.
+function stripTransport(settings) {
+    if (!settings) {
+        return undefined;
+    }
+    const { transport: _transport, ...rest } = settings;
+    return rest;
+}
+function applyOverrideToDefinition(definition, override) {
+    if (!override) {
+        return definition;
+    }
+    return {
+        ...definition,
+        label: override.label ?? definition.label,
+        description: override.description ?? definition.description,
+    };
+}
+function createDerivedDefinition(providerId, baseDefinition, override) {
+    if (!override.label) {
+        throw new Error(`Custom provider '${providerId}' requires a label`);
+    }
+    return {
+        ...baseDefinition,
+        id: providerId,
+        label: override.label,
+        description: override.description ?? baseDefinition.description,
+    };
+}
+function mapPersistenceHandle(provider, handle) {
+    if (!handle) {
+        return null;
+    }
+    return {
+        ...handle,
+        provider,
+    };
+}
+function mapRuntimeInfo(provider, runtimeInfo) {
+    return {
+        ...runtimeInfo,
+        provider,
+    };
+}
+function mapStreamEvent(provider, event) {
+    return {
+        ...event,
+        provider,
+    };
+}
+function mapModel(provider, model) {
+    return normalizeAgentModelDefinition({ ...model, provider });
+}
+function mergeModels(provider, profileModels, additionalModels, runtimeModels, options) {
+    const baseModels = runtimeModels.map((model) => mapModel(provider, model));
+    if (profileModels.length > 0 && options?.profileModelsAreAdditive !== true) {
+        return mergeModelAdditions(provider, profileModels.map((model) => mapModel(provider, model)), additionalModels);
+    }
+    return mergeModelAdditions(provider, baseModels, [...profileModels, ...additionalModels]);
+}
+function mergeModelAdditions(provider, baseModels, modelAdditions) {
+    if (modelAdditions.length === 0) {
+        return baseModels;
+    }
+    const mergedModels = [...baseModels];
+    let hasAdditionalDefault = false;
+    for (const model of modelAdditions) {
+        const additionalModel = mapModel(provider, model);
+        hasAdditionalDefault || (hasAdditionalDefault = additionalModel.isDefault === true);
+        const existingIndex = mergedModels.findIndex((candidate) => candidate.id === model.id);
+        if (existingIndex === -1) {
+            mergedModels.push(additionalModel);
+            continue;
+        }
+        mergedModels[existingIndex] = {
+            ...mergedModels[existingIndex],
+            ...additionalModel,
+        };
+    }
+    if (!hasAdditionalDefault) {
+        return mergedModels;
+    }
+    const additionalDefaultIds = new Set(modelAdditions.filter((model) => model.isDefault === true).map((model) => model.id));
+    return mergedModels.map((model) => additionalDefaultIds.has(model.id) ? model : Object.assign({}, model, { isDefault: false }));
+}
+export function wrapSessionProvider(provider, inner) {
+    return {
+        provider,
+        id: inner.id,
+        capabilities: inner.capabilities,
+        get features() {
+            return inner.features;
+        },
+        run: (prompt, options) => inner.run(prompt, options),
+        startTurn: (prompt, options) => inner.startTurn(prompt, options),
+        subscribe: (callback) => inner.subscribe((event) => callback(mapStreamEvent(provider, event))),
+        async *streamHistory() {
+            for await (const event of inner.streamHistory()) {
+                yield mapStreamEvent(provider, event);
+            }
+        },
+        getRuntimeInfo: async () => mapRuntimeInfo(provider, await inner.getRuntimeInfo()),
+        getAvailableModes: () => inner.getAvailableModes(),
+        getCurrentMode: () => inner.getCurrentMode(),
+        setMode: (modeId) => inner.setMode(modeId),
+        getPendingPermissions: () => inner.getPendingPermissions(),
+        respondToPermission: (requestId, response) => inner.respondToPermission(requestId, response),
+        describePersistence: () => mapPersistenceHandle(provider, inner.describePersistence()),
+        interrupt: () => inner.interrupt(),
+        close: () => inner.close(),
+        // Background-task surface. Dropped here since it was introduced, and consumed in
+        // agent-manager with the same `typeof session.x !== "function"` duck-type, so on every
+        // `pool-*` agent listing / dismissing / reading a background task silently no-ops
+        // instead of failing. Found by diffing the AgentSession members against this literal;
+        // the guard test below now does that diff automatically.
+        getActiveBackgroundTaskCount: inner.getActiveBackgroundTaskCount?.bind(inner),
+        listBackgroundTasks: inner.listBackgroundTasks?.bind(inner),
+        readBackgroundTaskOutput: inner.readBackgroundTaskOutput?.bind(inner),
+        dismissBackgroundTask: inner.dismissBackgroundTask?.bind(inner),
+        listCommands: inner.listCommands?.bind(inner),
+        setModel: inner.setModel?.bind(inner),
+        setThinkingOption: inner.setThinkingOption?.bind(inner),
+        setFeature: inner.setFeature?.bind(inner),
+        revertConversation: inner.revertConversation?.bind(inner),
+        revertFiles: inner.revertFiles?.bind(inner),
+        revertBoth: inner.revertBoth?.bind(inner),
+        tryHandleOutOfBand: inner.tryHandleOutOfBand?.bind(inner),
+        // The third method this wrapper silently ate. Editing a message was broken on every
+        // `pool-*` profile -- which is what the super-repo automation loops and the phone
+        // actually run -- while the undecorated `claude` provider worked, so the fix looked
+        // shipped and was inert where it mattered. Same shape as the `supportsToolAllowlist`
+        // and `options` losses documented in wrapClientProvider below.
+        resolveTranscriptTurnId: inner.resolveTranscriptTurnId?.bind(inner),
+        capturePane: inner.capturePane?.bind(inner),
+    };
+}
+export function wrapClientProvider(provider, inner, profileModels, additionalModels, profileModelsAreAdditive) {
+    const listImportableSessions = inner.listImportableSessions?.bind(inner);
+    const importSession = inner.importSession?.bind(inner);
+    return {
+        provider,
+        capabilities: inner.capabilities,
+        // Same forwarding trap as `options` below, one property up: this wrapper builds a
+        // fresh object literal, so any capability flag it forgets is silently LOST for every
+        // derived provider. `supportsToolAllowlist` is declared only on ClaudeAgentClient, and
+        // without this line every pool/pool-* profile (which is what the super-repo automation
+        // loops actually run on) was refused a tool allowlist with AGENT_CREATE_FAILED, while
+        // the undecorated `claude` provider worked, so the capability looked present in every
+        // direct-client test.
+        supportsToolAllowlist: inner.supportsToolAllowlist,
+        // `options` is load-bearing and MUST be forwarded. It carries
+        // AgentCreateSessionOptions -- today persistSession and the Story 3.6
+        // `resumeSessionId`. Declaring the arrow with only (config, launchContext)
+        // is not a type error, because JS/TS happily accept a function of lower
+        // arity where a higher-arity signature is expected, so dropping the third
+        // argument compiled silently and TypeScript could never warn.
+        //
+        // The effect: any provider that gets wrapped -- i.e. any provider with
+        // configured profile/additionalModels -- lost `--resume` entirely. Clicking
+        // a Cmd+K hit opened a blank chat, while an UNWRAPPED provider resumed fine,
+        // which is why every unit and daemon E2E test passed: they all inject the
+        // concrete client directly and never exercise the wrapper. `resumeSession`
+        // below forwards all three of its arguments, which is why `paseo import`
+        // kept working throughout and made this look like a create-path bug.
+        createSession: async (config, launchContext, options) => wrapSessionProvider(provider, await inner.createSession({
+            ...config,
+            provider: inner.provider,
+        }, launchContext, options)),
+        resumeSession: async (handle, overrides, launchContext) => wrapSessionProvider(provider, await inner.resumeSession({
+            ...handle,
+            provider: inner.provider,
+        }, overrides
+            ? {
+                ...overrides,
+                provider: inner.provider,
+            }
+            : undefined, launchContext)),
+        fetchCatalog: async (options) => {
+            const catalog = await inner.fetchCatalog(options);
+            return {
+                models: mergeModels(provider, profileModels, additionalModels, catalog.models, {
+                    profileModelsAreAdditive,
+                }),
+                modes: catalog.modes,
+            };
+        },
+        resolveCreateConfig: inner.resolveCreateConfig?.bind(inner),
+        isCreateConfigUnattended: inner.isCreateConfigUnattended?.bind(inner),
+        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),
+    };
+}
+function createRegistryEntry(logger, provider, resolved) {
+    const modelClient = resolved.createBaseClient(logger);
+    const hasReplacementModels = resolved.profileModels.length > 0 && !resolved.profileModelsAreAdditive;
+    const replacementModels = hasReplacementModels
+        ? resolved.profileModels.map((model) => mapModel(provider, model))
+        : [];
+    const decorateModes = (modes) => modes.map((mode) => {
+        if (mode.icon && mode.colorTier)
+            return mode;
+        const definitionMode = resolved.definition.modes.find((d) => d.id === mode.id);
+        if (!definitionMode)
+            return mode;
+        return Object.assign({}, mode, {
+            icon: mode.icon ?? definitionMode.icon,
+            colorTier: mode.colorTier ?? definitionMode.colorTier,
+        });
+    });
+    const hasStaticModes = resolved.definition.modes.length > 0;
+    return {
+        ...resolved.definition,
+        enabled: resolved.enabled,
+        derivedFromProviderId: resolved.derivedFromProviderId,
+        createClient: (providerLogger) => createResolvedProviderClient(providerLogger, provider, resolved),
+        resolveCreateConfig: modelClient.resolveCreateConfig ?? resolveDefaultAgentCreateConfig,
+        isCreateConfigUnattended: modelClient.isCreateConfigUnattended ?? isDefaultAgentCreateConfigUnattended,
+        fetchCatalog: async (options, client) => {
+            const catalogClient = client ?? modelClient;
+            if (hasReplacementModels) {
+                // Replacement models skip runtime model discovery, but additionalModels
+                // must still be merged on top. If modes are dynamic, probe for modes via
+                // the single catalog API; otherwise use static/empty modes with no runtime.
+                const models = mergeModelAdditions(provider, replacementModels, resolved.additionalModels);
+                if (hasStaticModes) {
+                    return {
+                        models,
+                        modes: decorateModes(resolved.definition.modes),
+                    };
+                }
+                const catalog = await catalogClient.fetchCatalog(options);
+                return { models, modes: decorateModes(catalog.modes) };
+            }
+            const catalog = await catalogClient.fetchCatalog(options);
+            return {
+                models: mergeModels(provider, resolved.profileModels, resolved.additionalModels, catalog.models, {
+                    profileModelsAreAdditive: resolved.profileModelsAreAdditive,
+                }),
+                modes: decorateModes(catalog.modes),
+            };
+        },
+    };
+}
+function createResolvedProviderClient(logger, provider, resolved) {
+    const inner = resolved.createBaseClient(logger);
+    const hasModelOverrides = resolved.profileModels.length > 0 || resolved.additionalModels.length > 0;
+    if (inner.provider === provider && !hasModelOverrides) {
+        return inner;
+    }
+    return wrapClientProvider(provider, inner, resolved.profileModels, resolved.additionalModels, resolved.profileModelsAreAdditive);
+}
+function buildResolvedBuiltinProviders(providerOverrides, runtimeSettings, options, isDev) {
+    const resolvedProviders = new Map();
+    const definitions = isDev
+        ? [...AGENT_PROVIDER_DEFINITIONS, ...DEV_AGENT_PROVIDER_DEFINITIONS]
+        : AGENT_PROVIDER_DEFINITIONS;
+    for (const definition of definitions) {
+        const override = providerOverrides[definition.id];
+        const factory = getProviderClientFactory(definition.id);
+        const mergedRuntimeSettings = mergeRuntimeSettings(runtimeSettings?.[definition.id], toRuntimeSettings(override));
+        resolvedProviders.set(definition.id, {
+            definition: applyOverrideToDefinition(definition, override),
+            runtimeSettings: mergedRuntimeSettings,
+            profileModels: override?.models ?? [],
+            additionalModels: override?.additionalModels ?? [],
+            profileModelsAreAdditive: false,
+            enabled: override?.enabled ?? definition.enabledByDefault ?? true,
+            derivedFromProviderId: null,
+            providerParams: override?.params,
+            createBaseClient: (logger) => factory(logger, mergedRuntimeSettings, {
+                workspaceGitService: options.workspaceGitService,
+                managedProcesses: options.managedProcesses,
+                providerParams: override?.params,
+            }),
+        });
+    }
+    return resolvedProviders;
+}
+/**
+ * Materialize ONE custom provider declared in `agents.providers` into the
+ * resolved map. Throws when the entry cannot be resolved; the caller decides
+ * whether that is fatal (it is not - see {@link addDerivedProviders}).
+ */
+function resolveDerivedProvider(providerId, override, resolvedProviders, options) {
+    if (!override.extends) {
+        throw new Error(`Custom provider '${providerId}' requires an extends value`);
+    }
+    if (override.extends === "acp") {
+        if (!override.command || !isNonEmptyStringArray(override.command)) {
+            throw new Error(`ACP provider '${providerId}' requires a command`);
+        }
+        // Capture command in const for closure - TypeScript can't track type refinement inside closures
+        const command = override.command;
+        resolvedProviders.set(providerId, {
+            definition: createDerivedDefinition(providerId, {
+                id: providerId,
+                label: override.label ?? providerId,
+                description: override.description ?? "Custom ACP provider",
+                defaultModeId: null,
+                modes: [],
+                wireFamily: "generic-acp",
+                compatibleProviders: [],
+            }, override),
+            runtimeSettings: toRuntimeSettings(override),
+            profileModels: override.models ?? [],
+            additionalModels: override.additionalModels ?? [],
+            profileModelsAreAdditive: false,
+            enabled: override.enabled !== false,
+            derivedFromProviderId: null,
+            providerParams: override.params,
+            createBaseClient: (logger) => {
+                const acpOptions = {
+                    logger,
+                    command,
+                    env: override.env,
+                    providerId,
+                    label: override.label ?? providerId,
+                    providerParams: override.params,
+                };
+                if (providerId === "cursor") {
+                    return new CursorACPAgentClient(acpOptions);
+                }
+                if (providerId === "kiro") {
+                    return new KiroACPAgentClient(acpOptions);
+                }
+                return new GenericACPAgentClient(acpOptions);
+            },
+        });
+        return;
+    }
+    const baseProviderId = override.extends;
+    const baseProvider = resolvedProviders.get(baseProviderId);
+    if (!baseProvider) {
+        throw new Error(`Custom provider '${providerId}' extends unknown provider '${baseProviderId}'`);
+    }
+    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,
+        profileModels: override.models ?? [],
+        additionalModels: override.additionalModels ?? [],
+        profileModelsAreAdditive: false,
+        enabled: override.enabled !== false,
+        derivedFromProviderId: baseProviderId,
+        providerParams,
+        createBaseClient: (logger) => baseFactory(logger, mergedRuntimeSettings, {
+            managedProcesses: options.managedProcesses,
+            providerParams,
+            customProvider: {
+                id: providerId,
+                label: override.label ?? providerId,
+                extends: baseProviderId,
+            },
+        }),
+    });
+}
+/**
+ * Resolve every custom (non-builtin) provider declared in `agents.providers`.
+ *
+ * WHY ONE BAD ENTRY IS NOT FATAL: this used to throw on the first unresolvable
+ * entry, which aborted the ENTIRE registry rebuild. Since the rebuild is what
+ * `paseo provider reload` runs, a single malformed provider made every provider
+ * change impossible until the daemon was restarted - and restarting cycles every
+ * live agent on the box. The blast radius of one typo was the whole fleet.
+ *
+ * So a provider that cannot be resolved is skipped and reported, and the other
+ * forty are applied. Skipping SILENTLY would be its own bug, so every skip is
+ * both logged and pushed onto `skipped`, which `paseo provider reload` prints
+ * back to the user alongside the added/updated/removed rows.
+ */
+function addDerivedProviders(resolvedProviders, providerOverrides, options, logger, skipped) {
+    for (const [providerId, override] of Object.entries(providerOverrides)) {
+        if (resolvedProviders.has(providerId) || BUILTIN_PROVIDER_IDS.includes(providerId)) {
+            continue;
+        }
+        try {
+            resolveDerivedProvider(providerId, override, resolvedProviders, options);
+        }
+        catch (error) {
+            const reason = error instanceof Error ? error.message : String(error);
+            skipped.push({ provider: providerId, reason });
+            logger.warn({ provider: providerId, reason }, "Skipping unresolvable custom provider; the rest of the registry is unaffected");
+        }
+    }
+}
+export function buildProviderRegistry(logger, options) {
+    const runtimeSettings = options?.runtimeSettings;
+    const providerOverrides = options?.providerOverrides ?? {};
+    const resolvedProviders = buildResolvedBuiltinProviders(providerOverrides, runtimeSettings, {
+        workspaceGitService: options?.workspaceGitService,
+        managedProcesses: options?.managedProcesses,
+    }, options?.isDev === true);
+    addDerivedProviders(resolvedProviders, providerOverrides, { managedProcesses: options?.managedProcesses }, logger, options?.skipped ?? []);
+    // Compute hot-swap compatibility across the full set of resolved providers
+    // (builtin + derived). Derived providers extending a builtin inherit
+    // bidirectional compatibility with their base + sibling derivatives.
+    // Asymmetric or wire-family-mismatched declarations are dropped + logged.
+    const extensionMap = new Map();
+    for (const [providerId, override] of Object.entries(providerOverrides)) {
+        if (override.extends && override.extends !== "acp") {
+            extensionMap.set(providerId, override.extends);
+        }
+    }
+    const definitionsForCompat = [...resolvedProviders.values()].map((entry) => entry.definition);
+    const compatibility = computeEffectiveCompatibleProviders(definitionsForCompat, extensionMap);
+    for (const warning of compatibility.warnings) {
+        logger.warn({ component: "provider-registry" }, warning);
+    }
+    // Splice the validated compatibility back into each resolved provider's
+    // definition so consumers (snapshot, AgentManager.swapAgentProvider, UI
+    // selector) see the effective swap targets — not the raw declared list.
+    for (const [providerId, resolved] of resolvedProviders.entries()) {
+        const effective = compatibility.effective.get(providerId);
+        resolvedProviders.set(providerId, {
+            ...resolved,
+            definition: {
+                ...resolved.definition,
+                compatibleProviders: effective ? [...effective] : [],
+            },
+        });
+    }
+    return Object.fromEntries([...resolvedProviders.entries()].map(([provider, resolved]) => [
+        provider,
+        createRegistryEntry(logger, provider, resolved),
+    ]));
+}
+export function getProviderIds(registry) {
+    return Object.keys(registry);
+}
+// Deprecated: Use buildProviderRegistry instead
+export const PROVIDER_REGISTRY = null;
+export function createAllClients(logger, options) {
+    return createClientsFromRegistry(buildProviderRegistry(logger, options), logger);
+}
+export function createClientsFromRegistry(registry, logger) {
+    return Object.fromEntries(Object.entries(registry).map(([provider, definition]) => [
+        provider,
+        definition.createClient(logger),
+    ]));
+}
+export async function shutdownProviders(logger, options) {
+    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