@hyperdrive.bot/fleet-server 0.3.99

package/dist/server/server/agent/create-agent-mode.d.ts

@@ -0,0 +1,13 @@
+import type { AgentCreateConfigParent, AgentCreateConfigUnattendedInput, AgentProvider, ResolveAgentCreateConfigInput, ResolveAgentCreateConfigResult } from "./agent-sdk-types.js";
+export interface ResolveCreateAgentModeInput {
+    requestedMode: string | undefined;
+    targetProvider: AgentProvider;
+    parent: AgentCreateConfigParent | null;
+    unattended: boolean;
+    availableModes: string[] | undefined;
+    targetUnattendedMode: string | undefined;
+}
+export declare function resolveAndValidateCreateAgentMode(input: ResolveCreateAgentModeInput): string | undefined;
+export declare function resolveDefaultAgentCreateConfig(input: ResolveAgentCreateConfigInput): ResolveAgentCreateConfigResult;
+export declare function isDefaultAgentCreateConfigUnattended(input: AgentCreateConfigUnattendedInput): boolean;
+//# sourceMappingURL=create-agent-mode.d.ts.map

package/dist/server/server/agent/create-agent-mode.js

@@ -0,0 +1,62 @@
+function listModes(modes) {
+    if (modes === undefined) {
+        return "unknown";
+    }
+    return modes.length > 0 ? modes.join(", ") : "(none)";
+}
+function isUnattendedCreateConfigParent(parent) {
+    return parent.isUnattended;
+}
+function formatCreateConfigParentMode(parent) {
+    return parent.modeId ?? "<none>";
+}
+function formatCreateConfigParentSource(parent) {
+    return `caller (provider '${parent.provider}')`;
+}
+export function resolveAndValidateCreateAgentMode(input) {
+    const { requestedMode, targetProvider, parent, availableModes } = input;
+    if (requestedMode !== undefined) {
+        if (availableModes !== undefined && !availableModes.includes(requestedMode)) {
+            throw new Error(`Invalid mode '${requestedMode}' for provider '${targetProvider}'. Available modes: ${listModes(availableModes)}`);
+        }
+        return requestedMode;
+    }
+    if (!parent) {
+        if (input.unattended && input.targetUnattendedMode !== undefined) {
+            return input.targetUnattendedMode;
+        }
+        return undefined;
+    }
+    if (parent.provider === targetProvider) {
+        return parent.modeId ?? undefined;
+    }
+    if ((input.unattended || isUnattendedCreateConfigParent(parent)) &&
+        input.targetUnattendedMode !== undefined) {
+        return input.targetUnattendedMode;
+    }
+    throw new Error(`cannot inherit mode '${formatCreateConfigParentMode(parent)}' from ${formatCreateConfigParentSource(parent)} for new agent (provider '${targetProvider}'). Pass an explicit mode. Available modes for '${targetProvider}': ${listModes(availableModes)}`);
+}
+export function resolveDefaultAgentCreateConfig(input) {
+    const availableModeIds = input.availableModes?.map((mode) => mode.id);
+    return {
+        modeId: resolveAndValidateCreateAgentMode({
+            requestedMode: input.requestedMode,
+            targetProvider: input.provider,
+            parent: input.parent,
+            unattended: input.unattended,
+            availableModes: availableModeIds,
+            targetUnattendedMode: input.availableModes?.find(isUnattendedMode)?.id,
+        }),
+        featureValues: input.featureValues,
+    };
+}
+export function isDefaultAgentCreateConfigUnattended(input) {
+    if (input.modeId === null) {
+        return false;
+    }
+    return input.availableModes.some((mode) => mode.id === input.modeId && isUnattendedMode(mode));
+}
+function isUnattendedMode(mode) {
+    return mode.isUnattended === true;
+}
+//# sourceMappingURL=create-agent-mode.js.map

package/dist/server/server/agent/create-agent-title.d.ts

@@ -0,0 +1,10 @@
+import type { FirstAgentContext } from "@hyperdrive.bot/fleet-protocol/messages";
+export declare function resolveCreateAgentTitles(options: {
+    configTitle?: string | null;
+    initialPrompt?: string | null;
+}): {
+    explicitTitle: string | null;
+    provisionalTitle: string | null;
+};
+export declare function resolveFirstAgentPromptTitle(firstAgentContext?: FirstAgentContext): string | null;
+//# sourceMappingURL=create-agent-title.d.ts.map

package/dist/server/server/agent/create-agent-title.js

@@ -0,0 +1,34 @@
+import { MAX_EXPLICIT_AGENT_TITLE_CHARS } from "@hyperdrive.bot/fleet-protocol/agent-title-limits";
+const MAX_INITIAL_AGENT_TITLE_CHARS = Math.min(60, MAX_EXPLICIT_AGENT_TITLE_CHARS);
+function deriveInitialAgentTitle(prompt) {
+    const firstContentLine = prompt
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .find((line) => line.length > 0);
+    if (!firstContentLine) {
+        return null;
+    }
+    const normalized = firstContentLine.replace(/\s+/g, " ").trim();
+    if (!normalized) {
+        return null;
+    }
+    const clamped = normalized.slice(0, MAX_INITIAL_AGENT_TITLE_CHARS).trim();
+    return clamped.length > 0 ? clamped : null;
+}
+export function resolveCreateAgentTitles(options) {
+    const explicitTitle = typeof options.configTitle === "string" && options.configTitle.trim().length > 0
+        ? options.configTitle.trim()
+        : null;
+    const trimmedPrompt = options.initialPrompt?.trim();
+    const provisionalTitle = explicitTitle ?? (trimmedPrompt ? deriveInitialAgentTitle(trimmedPrompt) : null);
+    return {
+        explicitTitle,
+        provisionalTitle,
+    };
+}
+export function resolveFirstAgentPromptTitle(firstAgentContext) {
+    return (resolveCreateAgentTitles({
+        initialPrompt: firstAgentContext?.prompt,
+    }).provisionalTitle ?? null);
+}
+//# sourceMappingURL=create-agent-title.js.map

package/dist/server/server/agent/dictation-debug.d.ts

@@ -0,0 +1,13 @@
+import type pino from "pino";
+export interface DictationDebugAudioMetadata {
+    sessionId: string;
+    dictationId: string;
+    format: string;
+}
+export interface DictationDebugChunkWriter {
+    folder: string;
+    writeChunk: (seq: number, pcm16: Buffer) => Promise<void>;
+}
+export declare function createDictationDebugChunkWriter(metadata: Pick<DictationDebugAudioMetadata, "sessionId" | "dictationId">, logger: pino.Logger): DictationDebugChunkWriter | null;
+export declare function maybePersistDictationDebugAudio(audio: Buffer, metadata: DictationDebugAudioMetadata, logger: pino.Logger, chunkWriterFolder?: string | null): Promise<string | null>;
+//# sourceMappingURL=dictation-debug.d.ts.map

package/dist/server/server/agent/dictation-debug.js

@@ -0,0 +1,50 @@
+import { mkdir, writeFile } from "fs/promises";
+import { join } from "path";
+import { inferAudioExtension, sanitizeForFilename } from "./audio-utils.js";
+import { resolveRecordingsDebugDir } from "./recordings-debug.js";
+let announcedDir = null;
+export function createDictationDebugChunkWriter(metadata, logger) {
+    const debugDir = resolveRecordingsDebugDir("DICTATION_DEBUG_AUDIO_DIR");
+    if (!debugDir) {
+        return null;
+    }
+    if (announcedDir !== debugDir) {
+        logger.info({ debugDir }, "Dictation audio capture enabled");
+        announcedDir = debugDir;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const folder = join(debugDir, sanitizeForFilename(metadata.sessionId, "session"), `${timestamp}_${sanitizeForFilename(metadata.dictationId, "dictation")}`);
+    let folderCreated = false;
+    return {
+        folder,
+        writeChunk: async (seq, pcm16) => {
+            if (!folderCreated) {
+                await mkdir(folder, { recursive: true });
+                folderCreated = true;
+            }
+            const paddedSeq = String(seq).padStart(6, "0");
+            const filePath = join(folder, `chunk_${paddedSeq}.pcm`);
+            await writeFile(filePath, pcm16);
+        },
+    };
+}
+export async function maybePersistDictationDebugAudio(audio, metadata, logger, chunkWriterFolder) {
+    const debugDir = resolveRecordingsDebugDir("DICTATION_DEBUG_AUDIO_DIR");
+    if (!debugDir) {
+        return null;
+    }
+    if (announcedDir !== debugDir) {
+        logger.info({ debugDir }, "Dictation audio capture enabled");
+        announcedDir = debugDir;
+    }
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const folder = chunkWriterFolder ?? join(debugDir, sanitizeForFilename(metadata.sessionId, "session"));
+    await mkdir(folder, { recursive: true });
+    const filename = chunkWriterFolder
+        ? `combined.${inferAudioExtension(metadata.format)}`
+        : `${timestamp}_${sanitizeForFilename(metadata.dictationId, "dictation")}.${inferAudioExtension(metadata.format)}`;
+    const filePath = join(folder, filename);
+    await writeFile(filePath, audio);
+    return filePath;
+}
+//# sourceMappingURL=dictation-debug.js.map

package/dist/server/server/agent/foreground-run-state.d.ts

@@ -0,0 +1,50 @@
+import { type AgentStreamEvent } from "./agent-sdk-types.js";
+export interface ForegroundTurnWaiter {
+    turnId: string;
+    callback: (event: AgentStreamEvent) => void;
+    settled: boolean;
+    settledPromise: Promise<void>;
+    resolveSettled: () => void;
+}
+export interface PendingForegroundRun {
+    token: string;
+    started: boolean;
+    settled: boolean;
+    settledPromise: Promise<void>;
+    resolveSettled: () => void;
+}
+export interface ForegroundRunAgentState {
+    foregroundTurnWaiters: Set<ForegroundTurnWaiter>;
+    finalizedForegroundTurnIds: Set<string>;
+}
+export declare class ForegroundRunState {
+    private readonly pendingRuns;
+    createPendingRun(agentId: string): PendingForegroundRun;
+    getPendingRun(agentId: string): PendingForegroundRun | null;
+    hasPendingRun(agentId: string): boolean;
+    settlePendingRun(agentId: string, token?: string): void;
+    createTurnStream(turnId: string): ForegroundTurnStream;
+    addWaiter(agent: ForegroundRunAgentState, waiter: ForegroundTurnWaiter): void;
+    deleteWaiter(agent: ForegroundRunAgentState, waiter: ForegroundTurnWaiter): void;
+    settleWaiter(waiter: ForegroundTurnWaiter): void;
+    getMatchingWaiters(agent: ForegroundRunAgentState, turnId: string | undefined): ForegroundTurnWaiter[];
+    notifyWaiters(waiters: Iterable<ForegroundTurnWaiter>, event: AgentStreamEvent, options: {
+        terminal: boolean;
+    }): void;
+    notifyAgentWaiters(agent: ForegroundRunAgentState, event: AgentStreamEvent, options?: {
+        terminal?: boolean;
+    }): void;
+    cancelWaiters(agent: ForegroundRunAgentState, createEvent: (turnId: string) => AgentStreamEvent): void;
+    clearAgent(agentId: string, agent: ForegroundRunAgentState): void;
+    rememberFinalizedTurn(agent: ForegroundRunAgentState, turnId: string): void;
+    hasFinalizedTurn(agent: ForegroundRunAgentState, turnId: string): boolean;
+}
+export declare class ForegroundTurnStream {
+    private readonly queue;
+    private queueResolve;
+    readonly waiter: ForegroundTurnWaiter;
+    constructor(turnId: string);
+    events(isTerminalEvent: (event: AgentStreamEvent) => boolean): AsyncGenerator<AgentStreamEvent>;
+    private wake;
+}
+//# sourceMappingURL=foreground-run-state.d.ts.map

package/dist/server/server/agent/foreground-run-state.js

@@ -0,0 +1,160 @@
+import { randomUUID } from "node:crypto";
+import { getAgentStreamEventTurnId } from "./agent-sdk-types.js";
+export class ForegroundRunState {
+    constructor() {
+        this.pendingRuns = new Map();
+    }
+    createPendingRun(agentId) {
+        const pendingRun = createPendingForegroundRun();
+        this.pendingRuns.set(agentId, pendingRun);
+        return pendingRun;
+    }
+    getPendingRun(agentId) {
+        return this.pendingRuns.get(agentId) ?? null;
+    }
+    hasPendingRun(agentId) {
+        return this.pendingRuns.has(agentId);
+    }
+    settlePendingRun(agentId, token) {
+        const pendingRun = this.pendingRuns.get(agentId);
+        if (!pendingRun) {
+            return;
+        }
+        if (token && pendingRun.token !== token) {
+            return;
+        }
+        this.pendingRuns.delete(agentId);
+        settlePendingForegroundRun(pendingRun);
+    }
+    createTurnStream(turnId) {
+        return new ForegroundTurnStream(turnId);
+    }
+    addWaiter(agent, waiter) {
+        agent.foregroundTurnWaiters.add(waiter);
+    }
+    deleteWaiter(agent, waiter) {
+        agent.foregroundTurnWaiters.delete(waiter);
+        this.settleWaiter(waiter);
+    }
+    settleWaiter(waiter) {
+        if (waiter.settled) {
+            return;
+        }
+        waiter.settled = true;
+        waiter.resolveSettled();
+    }
+    getMatchingWaiters(agent, turnId) {
+        if (turnId == null) {
+            return [];
+        }
+        return Array.from(agent.foregroundTurnWaiters).filter((waiter) => waiter.turnId === turnId && !waiter.settled);
+    }
+    notifyWaiters(waiters, event, options) {
+        for (const waiter of waiters) {
+            waiter.callback(event);
+            if (options.terminal) {
+                this.settleWaiter(waiter);
+            }
+        }
+    }
+    notifyAgentWaiters(agent, event, options) {
+        const waiters = this.getMatchingWaiters(agent, getAgentStreamEventTurnId(event));
+        this.notifyWaiters(waiters, event, { terminal: options?.terminal ?? false });
+    }
+    cancelWaiters(agent, createEvent) {
+        for (const waiter of agent.foregroundTurnWaiters) {
+            waiter.callback(createEvent(waiter.turnId));
+            this.settleWaiter(waiter);
+        }
+        agent.foregroundTurnWaiters.clear();
+    }
+    clearAgent(agentId, agent) {
+        for (const waiter of agent.foregroundTurnWaiters) {
+            this.settleWaiter(waiter);
+        }
+        agent.foregroundTurnWaiters.clear();
+        this.settlePendingRun(agentId);
+    }
+    rememberFinalizedTurn(agent, turnId) {
+        agent.finalizedForegroundTurnIds.add(turnId);
+        if (agent.finalizedForegroundTurnIds.size <= 50) {
+            return;
+        }
+        const oldest = agent.finalizedForegroundTurnIds.values().next().value;
+        if (oldest) {
+            agent.finalizedForegroundTurnIds.delete(oldest);
+        }
+    }
+    hasFinalizedTurn(agent, turnId) {
+        return agent.finalizedForegroundTurnIds.has(turnId);
+    }
+}
+export class ForegroundTurnStream {
+    constructor(turnId) {
+        this.queue = [];
+        this.queueResolve = null;
+        let resolveSettled;
+        const settledPromise = new Promise((resolvePromise) => {
+            resolveSettled = resolvePromise;
+        });
+        this.waiter = {
+            turnId,
+            settled: false,
+            settledPromise,
+            resolveSettled,
+            callback: (event) => {
+                this.queue.push(event);
+                this.wake();
+            },
+        };
+    }
+    async *events(isTerminalEvent) {
+        let done = false;
+        while (!done) {
+            while (this.queue.length > 0) {
+                const event = this.queue.shift();
+                yield event;
+                if (isTerminalEvent(event)) {
+                    done = true;
+                    break;
+                }
+            }
+            if (!done && this.queue.length === 0) {
+                if (this.waiter.settled) {
+                    break;
+                }
+                await new Promise((resolvePromise) => {
+                    this.queueResolve = resolvePromise;
+                });
+            }
+        }
+    }
+    wake() {
+        if (!this.queueResolve) {
+            return;
+        }
+        this.queueResolve();
+        this.queueResolve = null;
+    }
+}
+function createPendingForegroundRun() {
+    let resolveSettled;
+    const settledPromise = new Promise((resolvePromise) => {
+        resolveSettled = resolvePromise;
+    });
+    return {
+        token: randomUUID(),
+        started: false,
+        settled: false,
+        settledPromise,
+        resolveSettled,
+    };
+}
+function settlePendingForegroundRun(pendingRun) {
+    if (pendingRun.settled) {
+        return;
+    }
+    pendingRun.settled = true;
+    pendingRun.resolveSettled();
+}
+//# sourceMappingURL=foreground-run-state.js.map

package/dist/server/server/agent/import-sessions.d.ts

@@ -0,0 +1,52 @@
+import type { z } from "zod";
+import type { Logger } from "pino";
+import type { ProviderSnapshotManager } from "./provider-snapshot-manager.js";
+import type { AgentManager, ManagedAgent } from "./agent-manager.js";
+import type { AgentStorage, StoredAgentRecord } from "./agent-storage.js";
+import type { AgentProvider } from "./agent-sdk-types.js";
+import type { FetchRecentProviderSessionsRequestMessage, ImportAgentRequestMessageSchema, RecentProviderSessionDescriptorPayload } from "@hyperdrive.bot/fleet-protocol/messages";
+type ImportAgentRequestMessage = z.infer<typeof ImportAgentRequestMessageSchema>;
+export interface NormalizedImportAgentRequest {
+    provider: AgentProvider;
+    providerHandleId: string;
+    cwd?: string;
+    labels?: Record<string, string>;
+    requestId: string;
+}
+export declare class ImportSessionsRequestError extends Error {
+    readonly code: string;
+    constructor(code: string, message: string);
+}
+export interface ListImportableProviderSessionsInput {
+    request: FetchRecentProviderSessionsRequestMessage;
+    agentManager: Pick<AgentManager, "listAgents" | "listImportableSessions">;
+    agentStorage: Pick<AgentStorage, "list">;
+    providerSnapshotManager: Pick<ProviderSnapshotManager, "getProviderLabel">;
+}
+export interface ListImportableProviderSessionsResult {
+    entries: RecentProviderSessionDescriptorPayload[];
+    filteredAlreadyImportedCount: number;
+}
+export interface ImportProviderSessionInput {
+    request: NormalizedImportAgentRequest;
+    workspaceId: string;
+    agentManager: AgentManager;
+    agentStorage: AgentStorage;
+    logger: Logger;
+}
+export interface ImportProviderSessionResult {
+    snapshot: ManagedAgent;
+    timelineSize: number;
+}
+export declare function normalizeImportAgentRequest(msg: ImportAgentRequestMessage): NormalizedImportAgentRequest | {
+    error: string;
+};
+export declare function listImportableProviderSessions(input: ListImportableProviderSessionsInput): Promise<ListImportableProviderSessionsResult>;
+export declare function importProviderSession(input: ImportProviderSessionInput): Promise<ImportProviderSessionResult>;
+export declare function inheritedImportConfig(record: StoredAgentRecord | undefined): {
+    model?: string;
+    thinkingOptionId?: string;
+    modeId?: string;
+} | undefined;
+export {};
+//# sourceMappingURL=import-sessions.d.ts.map

package/dist/server/server/agent/import-sessions.js

@@ -0,0 +1,170 @@
+import { unarchiveAgentState } from "./agent-prompt.js";
+import { toRecentProviderSessionDescriptorPayload } from "./agent-projections.js";
+import { createRealpathAwarePathMatcher } from "../../utils/path.js";
+const METADATA_GENERATION_PROMPT_PREFIX = "Generate metadata for a coding agent based on the user prompt.";
+export class ImportSessionsRequestError extends Error {
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "ImportSessionsRequestError";
+    }
+}
+// COMPAT(import-agent-request-v1): accept legacy {provider, sessionId} shape
+// alongside the new {providerId, providerHandleId} shape. Old clients
+// (< target daemon floor) send the legacy fields. Drop the fallbacks and the
+// .optional() in messages.ts when the supported client floor is >= the daemon
+// version that ships the new shape (target: 2026-11-08).
+export function normalizeImportAgentRequest(msg) {
+    const provider = msg.providerId ?? msg.provider;
+    const providerHandleId = msg.providerHandleId ?? msg.sessionId;
+    if (!provider || !providerHandleId) {
+        return { error: "Import requires providerId and providerHandleId" };
+    }
+    return {
+        provider: provider,
+        providerHandleId,
+        cwd: msg.cwd,
+        labels: msg.labels,
+        requestId: msg.requestId,
+    };
+}
+export async function listImportableProviderSessions(input) {
+    const { request, agentManager, agentStorage, providerSnapshotManager } = input;
+    const limit = request.limit ?? 20;
+    const sinceTimestamp = parseRecentProviderSessionsSince(request.since);
+    const providerFilter = request.providers ? new Set(request.providers) : undefined;
+    const importedHandles = await collectImportedProviderSessionHandles(agentManager, agentStorage);
+    const sessions = await agentManager.listImportableSessions({
+        limit,
+        providerFilter,
+        cwd: request.cwd,
+    });
+    let filteredAlreadyImportedCount = 0;
+    const candidates = [];
+    const matchesRequestCwd = request.cwd ? createRealpathAwarePathMatcher(request.cwd) : null;
+    for (const session of sessions) {
+        if (matchesRequestCwd && !matchesRequestCwd(session.cwd)) {
+            continue;
+        }
+        if (sinceTimestamp !== null && session.lastActivityAt.getTime() < sinceTimestamp) {
+            continue;
+        }
+        if (isMetadataGenerationSession(session)) {
+            continue;
+        }
+        if (importedHandles.has(toProviderSessionHandleKey(session.provider, session.providerHandleId))) {
+            filteredAlreadyImportedCount += 1;
+            continue;
+        }
+        candidates.push(session);
+    }
+    const entries = candidates
+        .sort((a, b) => b.lastActivityAt.getTime() - a.lastActivityAt.getTime())
+        .slice(0, limit)
+        .map((descriptor) => toRecentProviderSessionDescriptorPayload(descriptor, {
+        providerLabel: providerSnapshotManager.getProviderLabel(descriptor.provider),
+    }));
+    return { entries, filteredAlreadyImportedCount };
+}
+export async function importProviderSession(input) {
+    const { provider, providerHandleId, cwd, labels } = input.request;
+    if (!cwd) {
+        throw new Error("Import requires cwd from the selected provider session");
+    }
+    const handle = buildImportPersistenceHandle({ provider, providerHandleId, cwd });
+    const priorRecord = await unarchiveAgentByHandle(input.agentStorage, input.agentManager, handle);
+    const inheritedConfig = inheritedImportConfig(priorRecord);
+    if (inheritedConfig) {
+        input.logger?.info?.({ providerHandleId, ...inheritedConfig }, "Import inheriting config from the session's previous agent record");
+    }
+    const snapshot = await input.agentManager.importProviderSession({
+        provider,
+        providerHandleId,
+        cwd,
+        workspaceId: input.workspaceId,
+        labels,
+        ...(inheritedConfig ? { config: inheritedConfig } : {}),
+    });
+    await unarchiveAgentState(input.agentStorage, input.agentManager, snapshot.id);
+    return {
+        snapshot,
+        timelineSize: input.agentManager.getTimeline(snapshot.id).length,
+    };
+}
+async function unarchiveAgentByHandle(agentStorage, agentManager, handle) {
+    const records = await agentStorage.list();
+    const matched = records.find((record) => record.persistence?.provider === handle.provider &&
+        (record.persistence.sessionId === handle.sessionId ||
+            record.persistence.nativeHandle === handle.nativeHandle));
+    if (!matched) {
+        return undefined;
+    }
+    await unarchiveAgentState(agentStorage, agentManager, matched.id);
+    return matched;
+}
+// An import that lands on a session paseo has seen before must not silently
+// downgrade it. The prior record already carries the model, thinking option and
+// permission mode the session was running under; without this the imported agent
+// falls back to daemon defaults, which has demoted a 1M-context session to the
+// 200k model and auto-compacted its transcript on the first prompt.
+export function inheritedImportConfig(record) {
+    if (!record) {
+        return undefined;
+    }
+    const modeId = record.lastModeId ?? record.config?.modeId ?? undefined;
+    const inherited = {
+        ...(record.config?.model ? { model: record.config.model } : {}),
+        ...(record.config?.thinkingOptionId
+            ? { thinkingOptionId: record.config.thinkingOptionId }
+            : {}),
+        ...(modeId ? { modeId } : {}),
+    };
+    return Object.keys(inherited).length > 0 ? inherited : undefined;
+}
+function parseRecentProviderSessionsSince(since) {
+    if (!since) {
+        return null;
+    }
+    const timestamp = Date.parse(since);
+    if (Number.isNaN(timestamp)) {
+        throw new ImportSessionsRequestError("invalid_since", "Invalid recent provider sessions since");
+    }
+    return timestamp;
+}
+function buildImportPersistenceHandle(input) {
+    return {
+        provider: input.provider,
+        sessionId: input.providerHandleId,
+        nativeHandle: input.providerHandleId,
+        metadata: {
+            provider: input.provider,
+            cwd: input.cwd,
+        },
+    };
+}
+async function collectImportedProviderSessionHandles(agentManager, agentStorage) {
+    const handles = new Set();
+    for (const agent of agentManager.listAgents()) {
+        collectProviderSessionHandleKeys(handles, agent.provider, agent.persistence);
+    }
+    for (const record of await agentStorage.list()) {
+        collectProviderSessionHandleKeys(handles, record.provider, record.persistence);
+    }
+    return handles;
+}
+function toProviderSessionHandleKey(provider, providerHandleId) {
+    return `${provider}\0${providerHandleId}`;
+}
+function isMetadataGenerationSession(input) {
+    return (input.firstPromptPreview?.trimStart().startsWith(METADATA_GENERATION_PROMPT_PREFIX) ?? false);
+}
+function collectProviderSessionHandleKeys(target, provider, persistence) {
+    if (!persistence) {
+        return;
+    }
+    target.add(toProviderSessionHandleKey(provider, persistence.sessionId));
+    if (persistence.nativeHandle) {
+        target.add(toProviderSessionHandleKey(provider, persistence.nativeHandle));
+    }
+}
+//# sourceMappingURL=import-sessions.js.map