@hyperdrive.bot/paseo-server 0.2.6

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

@@ -0,0 +1,578 @@
+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/paseo-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";
+    }
+}
+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) {
+        return undefined;
+    }
+    return {
+        command: override.command
+            ? {
+                mode: "replace",
+                argv: override.command,
+            }
+            : undefined,
+        env: override.env,
+        disallowedTools: override.disallowedTools,
+        transport: "sdk",
+    };
+}
+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(),
+        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),
+    };
+}
+function wrapClientProvider(provider, inner, profileModels, additionalModels, profileModelsAreAdditive) {
+    const listImportableSessions = inner.listImportableSessions?.bind(inner);
+    const importSession = inner.importSession?.bind(inner);
+    return {
+        provider,
+        capabilities: inner.capabilities,
+        createSession: async (config, launchContext) => wrapSessionProvider(provider, await inner.createSession({
+            ...config,
+            provider: inner.provider,
+        }, launchContext)),
+        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;
+}
+function addDerivedProviders(resolvedProviders, providerOverrides, options) {
+    for (const [providerId, override] of Object.entries(providerOverrides)) {
+        if (resolvedProviders.has(providerId) || BUILTIN_PROVIDER_IDS.includes(providerId)) {
+            continue;
+        }
+        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);
+                },
+            });
+            continue;
+        }
+        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,
+                },
+            }),
+        });
+    }
+}
+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,
+    });
+    // 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

package/dist/server/server/agent/provider-session-import.d.ts

@@ -0,0 +1,10 @@
+import type { AgentClient, AgentPersistenceHandle, AgentProvider, AgentSessionConfig, ImportedProviderSession, ImportProviderSessionContext, ImportProviderSessionInput } from "./agent-sdk-types.js";
+export declare function importSessionFromPersistence(input: {
+    provider: AgentProvider;
+    request: ImportProviderSessionInput;
+    context: ImportProviderSessionContext;
+    resumeSession: AgentClient["resumeSession"];
+    config?: Partial<AgentSessionConfig>;
+    persistence?: AgentPersistenceHandle;
+}): Promise<ImportedProviderSession>;
+//# sourceMappingURL=provider-session-import.d.ts.map

package/dist/server/server/agent/provider-session-import.js

@@ -0,0 +1,49 @@
+export async function importSessionFromPersistence(input) {
+    const config = {
+        ...input.context.config,
+        ...input.config,
+        provider: input.provider,
+        cwd: input.request.cwd,
+    };
+    const storedConfig = {
+        ...input.context.storedConfig,
+        ...input.config,
+        provider: input.provider,
+        cwd: input.request.cwd,
+    };
+    const persistence = input.persistence ?? buildImportPersistenceHandle(input.provider, input.request, storedConfig);
+    const session = await input.resumeSession(persistence, config, input.context.launchContext);
+    const timeline = await collectImportedTimeline(session.streamHistory());
+    return {
+        session,
+        config: storedConfig,
+        persistence,
+        timeline,
+    };
+}
+function buildImportPersistenceHandle(provider, input, config) {
+    return {
+        provider,
+        sessionId: input.providerHandleId,
+        nativeHandle: input.providerHandleId,
+        metadata: {
+            ...config,
+            provider,
+            cwd: input.cwd,
+        },
+    };
+}
+async function collectImportedTimeline(events) {
+    const timeline = [];
+    for await (const event of events) {
+        if (event.type !== "timeline") {
+            continue;
+        }
+        timeline.push({
+            item: event.item,
+            ...(event.timestamp ? { timestamp: event.timestamp } : {}),
+        });
+    }
+    return timeline;
+}
+//# sourceMappingURL=provider-session-import.js.map