@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/providers/omp/cli-runtime.d.ts

@@ -0,0 +1,22 @@
+import type { ChildProcessWithoutNullStreams } from "node:child_process";
+import type { Logger } from "pino";
+import type { ProviderRuntimeSettings } from "../../provider-launch-config.js";
+import { type OmpRuntime, type OmpRuntimeLaunch, type OmpRuntimeSession, type OmpStartSessionInput } from "./runtime.js";
+export interface OmpCliRuntimeOptions {
+    logger: Logger;
+    runtimeSettings?: ProviderRuntimeSettings;
+    command?: [string, ...string[]];
+    commandsRpcName?: "get_available_commands";
+    readyTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    spawnProcess?: (launch: OmpRuntimeLaunch) => ChildProcessWithoutNullStreams;
+}
+export declare class OmpCliRuntime implements OmpRuntime {
+    private readonly options;
+    private readonly command;
+    private readonly commandsRpcName;
+    private readonly spawnProcess?;
+    constructor(options: OmpCliRuntimeOptions);
+    startSession(input: OmpStartSessionInput): Promise<OmpRuntimeSession>;
+}
+//# sourceMappingURL=cli-runtime.d.ts.map

package/dist/server/server/agent/providers/omp/cli-runtime.js

@@ -0,0 +1,208 @@
+import { JsonlRpcProcess } from "../jsonl-rpc-process.js";
+import { establishOmpProtocol } from "./protocol-session.js";
+import { buildOmpLaunch, } from "./runtime.js";
+import { OmpBranchMessagesResultSchema, OmpBranchResultSchema, OmpCommandsResultSchema, OmpHostToolsResultSchema, OmpMessagesResultSchema, OmpModelSchema, OmpModelsResultSchema, OmpPromptAckSchema, OmpRpcCommandSchema, OmpRuntimeEventSchema, OmpSessionStateSchema, OmpSessionStatsSchema, } from "./rpc-types.js";
+const DEFAULT_OMP_COMMAND = [process.env.OMP_COMMAND ?? "omp"];
+const DEFAULT_COMMANDS_RPC_NAME = "get_available_commands";
+export class OmpCliRuntime {
+    constructor(options) {
+        this.options = options;
+        this.command = options.command ?? DEFAULT_OMP_COMMAND;
+        this.commandsRpcName = options.commandsRpcName ?? DEFAULT_COMMANDS_RPC_NAME;
+        this.spawnProcess = options.spawnProcess;
+    }
+    async startSession(input) {
+        const launch = buildOmpLaunch({
+            command: this.command,
+            runtimeSettings: this.options.runtimeSettings,
+            session: input,
+        });
+        const [command, ...args] = launch.argv;
+        const processLaunch = {
+            command,
+            args,
+            cwd: launch.cwd,
+            env: launch.env,
+        };
+        const spawn = this.spawnProcess;
+        const processOptions = {
+            launch: processLaunch,
+            logger: this.options.logger,
+            diagnosticName: "OMP RPC",
+            defaultRequestTimeoutMs: this.options.requestTimeoutMs,
+            ...(spawn ? { spawn: () => spawn(launch) } : {}),
+        };
+        const process = new JsonlRpcProcess(processOptions);
+        const handleAbort = () => void process.close(input.signal?.reason).catch(() => undefined);
+        input.signal?.addEventListener("abort", handleAbort, { once: true });
+        try {
+            await establishOmpProtocol(process, this.options.logger, {
+                readyTimeoutMs: this.options.readyTimeoutMs,
+                requestTimeoutMs: this.options.requestTimeoutMs,
+            });
+            input.signal?.throwIfAborted();
+            return new OmpCliRuntimeSession(process, this.commandsRpcName);
+        }
+        catch (error) {
+            const startupError = error instanceof Error ? error : new Error(String(error));
+            await process.close(startupError);
+            throw startupError;
+        }
+        finally {
+            input.signal?.removeEventListener("abort", handleAbort);
+        }
+    }
+}
+class OmpCliRuntimeSession {
+    constructor(process, commandsRpcName) {
+        this.process = process;
+        this.commandsRpcName = commandsRpcName;
+        this.subscribers = new Set();
+        process.onMessage((message) => {
+            const event = OmpRuntimeEventSchema.safeParse(message);
+            if (event.success) {
+                this.emit(event.data);
+            }
+        });
+        process.onExit(({ error }) => {
+            this.emit({ type: "process_exit", error: error.message });
+        });
+    }
+    onEvent(callback) {
+        this.subscribers.add(callback);
+        return () => {
+            this.subscribers.delete(callback);
+        };
+    }
+    async prompt(message, images) {
+        const { id: requestId, promise } = this.process.startRequest({
+            type: "prompt",
+            message,
+            ...(images?.length ? { images } : {}),
+        });
+        const ack = OmpPromptAckSchema.parse(await promise) ?? {};
+        return { requestId, ...ack };
+    }
+    async compact(customInstructions) {
+        await this.request({
+            type: "compact",
+            ...(customInstructions ? { customInstructions } : {}),
+        });
+    }
+    async setAutoCompaction(enabled) {
+        await this.request({ type: "set_auto_compaction", enabled });
+    }
+    async abort() {
+        await this.request({ type: "abort" });
+    }
+    async getState() {
+        return OmpSessionStateSchema.parse(await this.request({ type: "get_state" }));
+    }
+    async getMessages() {
+        const data = OmpMessagesResultSchema.parse(await this.request({ type: "get_messages" }));
+        return data.messages ?? [];
+    }
+    async getAvailableModels(timeoutMs) {
+        const data = OmpModelsResultSchema.parse(await this.request({ type: "get_available_models" }, timeoutMs));
+        return data.models ?? [];
+    }
+    async setModel(provider, modelId) {
+        return OmpModelSchema.parse(await this.request({ type: "set_model", provider, modelId }));
+    }
+    async setThinkingLevel(level) {
+        await this.request({ type: "set_thinking_level", level });
+    }
+    async getSessionStats() {
+        // COMPAT(ompGetStateFallback): added in v0.1.105 — older OMP binaries
+        // lack the `get_session_stats` RPC command; fall back to extracting
+        // context window usage from `get_state`. Remove after 2027-01-10 once the
+        // supported OMP floor includes `get_session_stats`.
+        let stats;
+        try {
+            stats = OmpSessionStatsSchema.parse(await this.request({ type: "get_session_stats" }));
+        }
+        catch {
+            // get_session_stats not supported by this binary — will try get_state below
+        }
+        if (stats?.tokens == null && stats?.cost == null && stats?.contextUsage == null) {
+            try {
+                const state = OmpSessionStateSchema.parse(await this.request({ type: "get_state" }));
+                const ctx = state.contextUsage;
+                if (ctx) {
+                    return {
+                        contextUsage: {
+                            tokens: typeof ctx.tokens === "number" ? ctx.tokens : undefined,
+                            contextWindow: typeof ctx.contextWindow === "number" ? ctx.contextWindow : undefined,
+                        },
+                    };
+                }
+            }
+            catch {
+                // get_state also failed — nothing we can do
+            }
+        }
+        return stats ?? {};
+    }
+    async getCommands() {
+        const data = OmpCommandsResultSchema.parse(await this.request({ type: this.commandsRpcName }));
+        return data.commands ?? [];
+    }
+    async setSubagentSubscription(level) {
+        await this.request({ type: "set_subagent_subscription", level });
+    }
+    async setHostTools(tools) {
+        const data = OmpHostToolsResultSchema.parse(await this.request({ type: "set_host_tools", tools }));
+        return data.toolNames ?? [];
+    }
+    sendHostToolResult(result) {
+        this.process.send({ ...result });
+    }
+    sendHostToolUpdate(update) {
+        this.process.send({ ...update });
+    }
+    async branch(entryId) {
+        const data = OmpBranchResultSchema.parse(await this.request({ type: "branch", entryId }));
+        if (data.cancelled === true) {
+            throw new Error("OMP branch was cancelled");
+        }
+        if (typeof data.text !== "string") {
+            throw new Error("OMP branch response did not include restored prompt text");
+        }
+        this.activeBranchEntryId = entryId;
+        return { text: data.text };
+    }
+    async getBranchMessages() {
+        const data = OmpBranchMessagesResultSchema.parse(await this.request({ type: "get_branch_messages" }));
+        return data.messages ?? [];
+    }
+    steer(message, images) {
+        this.process.send({ type: "steer", message, ...(images?.length ? { images } : {}) });
+    }
+    followUp(message, images) {
+        this.process.send({ type: "follow_up", message, ...(images?.length ? { images } : {}) });
+    }
+    async handoff(customInstructions) {
+        await this.request({
+            type: "handoff",
+            ...(customInstructions ? { customInstructions } : {}),
+        });
+    }
+    respondToExtensionUiRequest(id, response) {
+        this.process.send({ type: "extension_ui_response", id, ...response });
+    }
+    cancelExtensionUiRequest(id) {
+        this.respondToExtensionUiRequest(id, { cancelled: true });
+    }
+    async close() {
+        await this.process.close(new Error("OMP RPC session is closed"));
+    }
+    request(command, timeoutMs) {
+        return this.process.request(OmpRpcCommandSchema.parse(command), timeoutMs);
+    }
+    emit(event) {
+        for (const subscriber of this.subscribers) {
+            subscriber(event);
+        }
+    }
+}
+//# sourceMappingURL=cli-runtime.js.map

package/dist/server/server/agent/providers/omp/commands.d.ts

@@ -0,0 +1,8 @@
+import type { AgentSlashCommand } from "../../agent-sdk-types.js";
+import type { OmpRpcSlashCommand } from "./rpc-types.js";
+import { type OmpAvailableCommand } from "./rpc-types.js";
+export declare const OMP_HANDLED_BUILTIN_SLASH_COMMANDS: readonly AgentSlashCommand[];
+export declare function mapOmpSlashCommands(commands: readonly OmpAvailableCommand[]): AgentSlashCommand[];
+export declare function mapOmpRuntimeSlashCommands(commands: readonly OmpRpcSlashCommand[]): AgentSlashCommand[];
+export declare function mapOmpAvailableCommandsUpdate(event: unknown): AgentSlashCommand[] | null;
+//# sourceMappingURL=commands.d.ts.map

package/dist/server/server/agent/providers/omp/commands.js

@@ -0,0 +1,62 @@
+import { OmpAvailableCommandsUpdateEventSchema } from "./rpc-types.js";
+export const OMP_HANDLED_BUILTIN_SLASH_COMMANDS = [
+    {
+        name: "compact",
+        description: "Manually compact the session context",
+        argumentHint: "[instructions]",
+        kind: "command",
+    },
+    {
+        name: "autocompact",
+        description: "Toggle automatic context compaction",
+        argumentHint: "[on|off|toggle]",
+        kind: "command",
+    },
+    {
+        name: "handoff",
+        description: "Hand off from planning to implementation",
+        argumentHint: "[instructions]",
+        kind: "command",
+    },
+    {
+        name: "steer",
+        description: "Steer the active OMP turn",
+        argumentHint: "<message>",
+        kind: "command",
+    },
+    {
+        name: "follow-up",
+        description: "Queue a follow-up message for OMP",
+        argumentHint: "<message>",
+        kind: "command",
+    },
+];
+export function mapOmpSlashCommands(commands) {
+    const mappedCommands = new Map(OMP_HANDLED_BUILTIN_SLASH_COMMANDS.map((command) => [command.name, { ...command }]));
+    for (const command of commands) {
+        const knownCommand = mappedCommands.get(command.name);
+        mappedCommands.set(command.name, {
+            name: command.name,
+            description: command.description ?? command.source ?? "command",
+            argumentHint: command.input?.hint ?? knownCommand?.argumentHint ?? "",
+            kind: mapOmpCommandKind(command.source),
+        });
+    }
+    return [...mappedCommands.values()];
+}
+export function mapOmpRuntimeSlashCommands(commands) {
+    return mapOmpSlashCommands(commands.map((command) => ({
+        name: command.name,
+        ...(command.description ? { description: command.description } : {}),
+        source: command.source,
+        ...(command.input ? { input: command.input } : {}),
+    })));
+}
+export function mapOmpAvailableCommandsUpdate(event) {
+    const parsed = OmpAvailableCommandsUpdateEventSchema.safeParse(event);
+    return parsed.success ? mapOmpSlashCommands(parsed.data.commands) : null;
+}
+function mapOmpCommandKind(source) {
+    return source === "skill" ? "skill" : "command";
+}
+//# sourceMappingURL=commands.js.map

package/dist/server/server/agent/providers/omp/custom-message.d.ts

@@ -0,0 +1,7 @@
+import type { OmpAgentMessage } from "./rpc-types.js";
+type OmpCustomMessage = Extract<OmpAgentMessage, {
+    role: "custom";
+}>;
+export declare function shouldDisplayOmpCustomMessage(message: OmpCustomMessage): boolean;
+export {};
+//# sourceMappingURL=custom-message.d.ts.map

package/dist/server/server/agent/providers/omp/custom-message.js

@@ -0,0 +1,4 @@
+export function shouldDisplayOmpCustomMessage(message) {
+    return Reflect.get(message, "display") !== false;
+}
+//# sourceMappingURL=custom-message.js.map

package/dist/server/server/agent/providers/omp/event-mapper.d.ts

@@ -0,0 +1,13 @@
+import type { AgentTimelineItem } from "../../agent-sdk-types.js";
+export type OmpRuntimeEventMapping = {
+    handled: false;
+} | {
+    handled: true;
+    item: AgentTimelineItem;
+} | {
+    handled: true;
+    item: null;
+    logReason: string;
+};
+export declare function mapOmpRuntimeEventToTimelineItem(event: unknown): OmpRuntimeEventMapping;
+//# sourceMappingURL=event-mapper.d.ts.map

package/dist/server/server/agent/providers/omp/event-mapper.js

@@ -0,0 +1,267 @@
+import { createHash } from "node:crypto";
+import { OmpAutoCompactionEndEventSchema, OmpAutoCompactionStartEventSchema, OmpAutoRetryEndEventSchema, OmpAutoRetryStartEventSchema, OmpGoalUpdatedEventSchema, OmpNoticeEventSchema, OmpRetryFallbackAppliedEventSchema, OmpRetryFallbackSucceededEventSchema, } from "./rpc-types.js";
+export function mapOmpRuntimeEventToTimelineItem(event) {
+    const type = readEventType(event);
+    switch (type) {
+        case "notice":
+            return mapNoticeEvent(event);
+        case "goal_updated":
+            return mapGoalUpdatedEvent(event);
+        case "auto_retry_start":
+            return mapAutoRetryStartEvent(event);
+        case "auto_retry_end":
+            return mapAutoRetryEndEvent(event);
+        case "retry_fallback_applied":
+            return mapRetryFallbackAppliedEvent(event);
+        case "retry_fallback_succeeded":
+            return mapRetryFallbackSucceededEvent(event);
+        case "auto_compaction_start":
+            return mapAutoCompactionStartEvent(event);
+        case "auto_compaction_end":
+            return mapAutoCompactionEndEvent(event);
+        default:
+            return { handled: false };
+    }
+}
+function mapNoticeEvent(event) {
+    const parsed = OmpNoticeEventSchema.safeParse(event);
+    if (!parsed.success) {
+        return { handled: true, item: null, logReason: "malformed_omp_notice" };
+    }
+    return {
+        handled: true,
+        item: {
+            type: "notification",
+            level: parsed.data.level,
+            message: parsed.data.message,
+        },
+    };
+}
+function mapGoalUpdatedEvent(event) {
+    const parsed = OmpGoalUpdatedEventSchema.safeParse(event);
+    if (!parsed.success) {
+        return { handled: true, item: null, logReason: "malformed_omp_goal_updated" };
+    }
+    const goal = resolveGoal(parsed.data);
+    const label = goal?.status ? `OMP goal ${goal.status}` : "OMP goal updated";
+    const text = formatGoalText(parsed.data, goal);
+    return {
+        handled: true,
+        item: buildStatusLineItem({
+            callId: `omp-goal:${goal?.id ?? hashParts(text)}`,
+            name: "omp_goal_updated",
+            label,
+            text,
+            icon: "brain",
+            metadata: {
+                synthetic: true,
+                source: "omp_goal_updated",
+                ...(goal?.id ? { goalId: goal.id } : {}),
+                ...(goal?.status ? { goalStatus: goal.status } : {}),
+            },
+        }),
+    };
+}
+function mapAutoRetryStartEvent(event) {
+    const parsed = OmpAutoRetryStartEventSchema.safeParse(event);
+    if (!parsed.success) {
+        return { handled: true, item: null, logReason: "malformed_omp_auto_retry_start" };
+    }
+    const data = parsed.data;
+    return {
+        handled: true,
+        item: buildStatusLineItem({
+            callId: `omp-auto-retry:${data.attempt}`,
+            name: "omp_auto_retry",
+            label: `OMP retry ${data.attempt}/${data.maxAttempts}`,
+            text: `Retrying in ${formatDelay(data.delayMs)}: ${data.errorMessage}`,
+            icon: "sparkles",
+            status: "running",
+            metadata: {
+                synthetic: true,
+                source: "omp_auto_retry_start",
+                attempt: data.attempt,
+                maxAttempts: data.maxAttempts,
+                delayMs: data.delayMs,
+                ...(data.errorId !== undefined ? { errorId: data.errorId } : {}),
+            },
+        }),
+    };
+}
+function mapAutoRetryEndEvent(event) {
+    const parsed = OmpAutoRetryEndEventSchema.safeParse(event);
+    if (!parsed.success) {
+        return { handled: true, item: null, logReason: "malformed_omp_auto_retry_end" };
+    }
+    const data = parsed.data;
+    const status = data.success ? "completed" : "failed";
+    return {
+        handled: true,
+        item: buildStatusLineItem({
+            callId: `omp-auto-retry:${data.attempt}`,
+            name: "omp_auto_retry",
+            label: data.success
+                ? `OMP retry ${data.attempt} recovered`
+                : `OMP retry ${data.attempt} failed`,
+            text: data.finalError ?? (data.success ? "Retry recovered." : "Retry failed."),
+            icon: "sparkles",
+            status,
+            error: data.success ? undefined : (data.finalError ?? "OMP retry failed"),
+            metadata: {
+                synthetic: true,
+                source: "omp_auto_retry_end",
+                attempt: data.attempt,
+                success: data.success,
+            },
+        }),
+    };
+}
+function mapRetryFallbackAppliedEvent(event) {
+    const parsed = OmpRetryFallbackAppliedEventSchema.safeParse(event);
+    if (!parsed.success) {
+        return { handled: true, item: null, logReason: "malformed_omp_retry_fallback_applied" };
+    }
+    const data = parsed.data;
+    return {
+        handled: true,
+        item: buildStatusLineItem({
+            callId: `omp-retry-fallback:${hashParts(data.role, data.from, data.to)}`,
+            name: "omp_retry_fallback",
+            label: `OMP fallback applied for ${data.role}`,
+            text: `${data.from} -> ${data.to}`,
+            icon: "sparkles",
+            metadata: {
+                synthetic: true,
+                source: "omp_retry_fallback_applied",
+                role: data.role,
+                from: data.from,
+                to: data.to,
+            },
+        }),
+    };
+}
+function mapRetryFallbackSucceededEvent(event) {
+    const parsed = OmpRetryFallbackSucceededEventSchema.safeParse(event);
+    if (!parsed.success) {
+        return { handled: true, item: null, logReason: "malformed_omp_retry_fallback_succeeded" };
+    }
+    const data = parsed.data;
+    return {
+        handled: true,
+        item: buildStatusLineItem({
+            callId: `omp-retry-fallback-succeeded:${hashParts(data.role, data.model)}`,
+            name: "omp_retry_fallback",
+            label: `OMP fallback succeeded for ${data.role}`,
+            text: `Using ${data.model}`,
+            icon: "sparkles",
+            metadata: {
+                synthetic: true,
+                source: "omp_retry_fallback_succeeded",
+                role: data.role,
+                model: data.model,
+            },
+        }),
+    };
+}
+function mapAutoCompactionStartEvent(event) {
+    const parsed = OmpAutoCompactionStartEventSchema.safeParse(event);
+    if (!parsed.success) {
+        return { handled: true, item: null, logReason: "malformed_omp_auto_compaction_start" };
+    }
+    return {
+        handled: true,
+        item: {
+            type: "compaction",
+            status: "loading",
+            trigger: "auto",
+        },
+    };
+}
+function mapAutoCompactionEndEvent(event) {
+    const parsed = OmpAutoCompactionEndEventSchema.safeParse(event);
+    if (!parsed.success) {
+        return { handled: true, item: null, logReason: "malformed_omp_auto_compaction_end" };
+    }
+    const preTokens = readCompactionPreTokens(parsed.data.result);
+    // Wire compaction items only support loading/completed, so every end event clears loading.
+    return {
+        handled: true,
+        item: {
+            type: "compaction",
+            status: "completed",
+            trigger: "auto",
+            ...(preTokens !== undefined ? { preTokens } : {}),
+        },
+    };
+}
+function buildStatusLineItem(input) {
+    const base = {
+        type: "tool_call",
+        callId: input.callId,
+        name: input.name,
+        detail: {
+            type: "plain_text",
+            label: input.label,
+            ...(input.text ? { text: input.text } : {}),
+            icon: input.icon ?? "sparkles",
+        },
+        metadata: input.metadata,
+    };
+    if (input.status === "running") {
+        return { ...base, status: "running", error: null };
+    }
+    if (input.status === "failed") {
+        return { ...base, status: "failed", error: input.error ?? input.text ?? input.label };
+    }
+    return { ...base, status: "completed", error: null };
+}
+function resolveGoal(event) {
+    return event.goal ?? event.state?.goal ?? null;
+}
+function formatGoalText(event, goal) {
+    if (!goal) {
+        return "OMP goal cleared.";
+    }
+    const parts = [
+        goal.objective?.trim() || "OMP goal updated.",
+        goal.status ? `Status: ${goal.status}` : null,
+        goal.tokensUsed !== undefined ? `Tokens used: ${goal.tokensUsed}` : null,
+        goal.tokenBudget !== undefined ? `Token budget: ${goal.tokenBudget}` : null,
+        goal.timeUsedSeconds !== undefined ? `Time used: ${goal.timeUsedSeconds}s` : null,
+        event.state?.mode ? `Mode: ${event.state.mode}` : null,
+    ].filter((part) => part !== null);
+    return parts.join("\n");
+}
+function readEventType(value) {
+    if (!isRecord(value)) {
+        return null;
+    }
+    return typeof value.type === "string" ? value.type : null;
+}
+function readCompactionPreTokens(value) {
+    if (!isRecord(value)) {
+        return undefined;
+    }
+    return typeof value.tokensBefore === "number" ? value.tokensBefore : undefined;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function formatDelay(delayMs) {
+    if (delayMs < 1000) {
+        return `${delayMs}ms`;
+    }
+    if (delayMs % 1000 === 0) {
+        return `${delayMs / 1000}s`;
+    }
+    return `${(delayMs / 1000).toFixed(1)}s`;
+}
+function hashParts(...parts) {
+    const hash = createHash("sha1");
+    for (const part of parts) {
+        hash.update(part);
+        hash.update("\0");
+    }
+    return hash.digest("hex").slice(0, 12);
+}
+//# sourceMappingURL=event-mapper.js.map

package/dist/server/server/agent/providers/omp/history-hooks.d.ts

@@ -0,0 +1,3 @@
+import type { OmpHistoryMapperHooks } from "./message-history.js";
+export declare const OMP_HISTORY_MAPPER_HOOKS: OmpHistoryMapperHooks;
+//# sourceMappingURL=history-hooks.d.ts.map

package/dist/server/server/agent/providers/omp/history-hooks.js

@@ -0,0 +1,13 @@
+import { mapOmpAdvisorMessageToToolCall } from "./advisor-message.js";
+import { mapOmpSystemNoticeToNotification } from "./system-notice.js";
+import { mapOmpToolDetail } from "./tool-call-mapper.js";
+import { resolveOmpEmittedToolCallId } from "./tool-call-id.js";
+export const OMP_HISTORY_MAPPER_HOOKS = {
+    mapToolDetail: mapOmpToolDetail,
+    mapCustomMessage: (message, text, provider) => {
+        const item = mapOmpAdvisorMessageToToolCall(message, text) ?? mapOmpSystemNoticeToNotification(text);
+        return item ? { type: "timeline", provider, item } : null;
+    },
+    resolveToolCallId: resolveOmpEmittedToolCallId,
+};
+//# sourceMappingURL=history-hooks.js.map

package/dist/server/server/agent/providers/omp/history.d.ts

@@ -0,0 +1,19 @@
+import type { AgentProvider, AgentStreamEvent } from "../../agent-sdk-types.js";
+import type { OmpRuntimeSession } from "./runtime.js";
+interface OmpSessionEntry {
+    type?: string;
+    id?: string;
+    parentId?: string | null;
+    timestamp?: string | number;
+    message?: Record<string, unknown>;
+    [key: string]: unknown;
+}
+export declare function streamOmpHistory(input: {
+    sessionFile?: string;
+    runtimeSession?: OmpRuntimeSession;
+    provider: AgentProvider;
+    visitedSessionFiles?: Set<string>;
+}): AsyncGenerator<AgentStreamEvent>;
+export declare function readActiveOmpEntryChain(sessionFile: string, activeEntryId?: string): Promise<OmpSessionEntry[]>;
+export {};
+//# sourceMappingURL=history.d.ts.map