@camerontaylor/paseo-server 0.8.0-fork.1

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

@@ -0,0 +1,306 @@
+import { readFile } from "node:fs/promises";
+import { basename, extname, join } from "node:path";
+import { normalizeProviderReplayTimestamp } from "../../provider-history-timestamps.js";
+import { OmpHistoryMapper } from "./message-history.js";
+import { OMP_HISTORY_MAPPER_HOOKS } from "./history-hooks.js";
+import { formatOmpSubagentTitle } from "./subagent-title.js";
+function extractOmpSubagentModel(entries) {
+    let resolvedModel = null;
+    for (const entry of entries) {
+        let candidate = null;
+        if (entry.type === "model_change") {
+            candidate = buildOmpModelId(entry.provider, entry.modelId);
+        }
+        else if (entry.type === "message" && entry.message?.role === "assistant") {
+            candidate = buildOmpModelId(entry.message.provider, entry.message.responseModel ?? entry.message.model);
+        }
+        resolvedModel = candidate ?? resolvedModel;
+    }
+    return resolvedModel;
+}
+function buildOmpModelId(provider, model) {
+    if (typeof provider !== "string" || typeof model !== "string")
+        return null;
+    const normalizedProvider = provider.trim();
+    const normalizedModel = model.trim();
+    return normalizedProvider && normalizedModel ? `${normalizedProvider}/${normalizedModel}` : null;
+}
+export async function* streamOmpHistory(input) {
+    if (!input.sessionFile) {
+        return;
+    }
+    const visitedSessionFiles = input.visitedSessionFiles ?? new Set();
+    if (visitedSessionFiles.has(input.sessionFile)) {
+        return;
+    }
+    visitedSessionFiles.add(input.sessionFile);
+    let entries;
+    try {
+        entries = await readActiveOmpEntryChain(input.sessionFile, input.runtimeSession?.activeBranchEntryId);
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return;
+        }
+        throw error;
+    }
+    const messages = [];
+    const messageEntries = [];
+    const userEntries = [];
+    for (const entry of entries) {
+        const mapped = mapEntryMessage(entry);
+        if (!mapped)
+            continue;
+        messages.push(mapped);
+        messageEntries.push(entry);
+        if (mapped.role === "user" && entry.id) {
+            userEntries.push({ id: entry.id, text: textOf(mapped.content) });
+        }
+    }
+    const mapper = new OmpHistoryMapper(input.provider, userEntries, OMP_HISTORY_MAPPER_HOOKS);
+    for (let index = 0; index < messages.length; index += 1) {
+        const timestamp = normalizeProviderReplayTimestamp(messageEntries[index]?.timestamp);
+        for (const event of mapper.mapMessages([messages[index]])) {
+            yield timestamp && event.type === "timeline" ? { ...event, timestamp } : event;
+        }
+    }
+    for (const transcript of readSubagentTranscripts(messages, input.sessionFile)) {
+        yield* replaySubagentTranscript(transcript, input.provider, visitedSessionFiles);
+    }
+}
+async function* replaySubagentTranscript(transcript, provider, visitedSessionFiles) {
+    const childEntries = await readActiveOmpEntryChain(transcript.sessionFile).catch((error) => {
+        if (error.code === "ENOENT")
+            return [];
+        throw error;
+    });
+    const resolvedModel = extractOmpSubagentModel(childEntries);
+    const firstTimestamp = normalizeProviderReplayTimestamp(childEntries[0]?.timestamp);
+    yield subagentUpsert(transcript, provider, "running", firstTimestamp, resolvedModel);
+    for await (const event of streamOmpHistory({
+        sessionFile: transcript.sessionFile,
+        provider,
+        visitedSessionFiles,
+    })) {
+        if (event.type === "timeline") {
+            yield {
+                type: "provider_subagent",
+                provider,
+                event: {
+                    type: "timeline",
+                    id: transcript.id,
+                    item: event.item,
+                    ...(event.timestamp ? { timestamp: event.timestamp } : {}),
+                },
+            };
+        }
+        else if (event.type === "provider_subagent") {
+            yield event;
+        }
+    }
+    const lastTimestamp = normalizeProviderReplayTimestamp(childEntries.at(-1)?.timestamp);
+    yield subagentUpsert(transcript, provider, transcript.status, lastTimestamp, resolvedModel);
+}
+function subagentUpsert(transcript, provider, status, timestamp, resolvedModel) {
+    return {
+        type: "provider_subagent",
+        provider,
+        event: {
+            type: "upsert",
+            id: transcript.id,
+            title: formatOmpSubagentTitle(transcript.title, resolvedModel),
+            status,
+            toolCallId: transcript.toolCallId,
+            ...(timestamp ? { timestamp } : {}),
+        },
+    };
+}
+function readSubagentTranscripts(messages, parentSessionFile) {
+    const taskCalls = collectTaskCalls(messages);
+    const transcripts = [];
+    for (const message of messages) {
+        if (message.role !== "toolResult" || message.toolName !== "task")
+            continue;
+        const call = taskCalls.get(message.toolCallId);
+        if (!call)
+            continue;
+        const results = readTaskResults(message);
+        for (const result of results) {
+            transcripts.push({
+                id: result.id,
+                title: result.agent ?? call.title,
+                toolCallId: message.toolCallId,
+                sessionFile: join(stripExtension(parentSessionFile), `${basename(result.id)}.jsonl`),
+                status: taskResultStatus(result, message.isError === true),
+            });
+        }
+        if (results.length > 0)
+            continue;
+        const legacy = readLegacyTranscript(message, call.title);
+        if (legacy)
+            transcripts.push(legacy);
+    }
+    return transcripts;
+}
+function collectTaskCalls(messages) {
+    const taskCalls = new Map();
+    for (const message of messages) {
+        if (message.role !== "assistant" || !Array.isArray(message.content))
+            continue;
+        for (const block of message.content) {
+            if (block.type !== "toolCall" || block.name !== "task" || typeof block.id !== "string") {
+                continue;
+            }
+            const args = block.arguments;
+            const title = args && typeof args === "object" && typeof Reflect.get(args, "agent") === "string"
+                ? Reflect.get(args, "agent")
+                : "OMP subagent";
+            taskCalls.set(block.id, { title });
+        }
+    }
+    return taskCalls;
+}
+function readLegacyTranscript(message, title) {
+    const text = taskResultText(message);
+    const sessionFile = text.match(/(?:session|transcript)(?: file)?:\s*(?<path>\/\S+\.jsonl)/i)
+        ?.groups?.path;
+    if (!sessionFile)
+        return null;
+    const fileName = basename(sessionFile);
+    const extension = extname(fileName);
+    return {
+        id: extension ? fileName.slice(0, -extension.length) : fileName,
+        title,
+        toolCallId: message.toolCallId,
+        sessionFile,
+        status: message.isError ? "failed" : "completed",
+    };
+}
+function readTaskResults(message) {
+    const details = Reflect.get(message, "details") ??
+        (message.content && typeof message.content === "object"
+            ? Reflect.get(message.content, "details")
+            : undefined);
+    const results = details && typeof details === "object" ? Reflect.get(details, "results") : undefined;
+    if (!Array.isArray(results))
+        return [];
+    return results.flatMap((result) => {
+        if (!result || typeof result !== "object")
+            return [];
+        const id = Reflect.get(result, "id");
+        if (typeof id !== "string" || !id)
+            return [];
+        const agent = Reflect.get(result, "agent");
+        const exitCode = Reflect.get(result, "exitCode");
+        return [
+            {
+                id,
+                ...(typeof agent === "string" ? { agent } : {}),
+                ...(typeof exitCode === "number" ? { exitCode } : {}),
+                error: Reflect.get(result, "error"),
+                aborted: Reflect.get(result, "aborted") === true,
+            },
+        ];
+    });
+}
+function taskResultStatus(result, messageIsError) {
+    if (messageIsError || result.error || (result.exitCode !== undefined && result.exitCode !== 0)) {
+        return "failed";
+    }
+    return result.aborted ? "canceled" : "completed";
+}
+function taskResultText(message) {
+    return Array.isArray(message.content)
+        ? message.content
+            .flatMap((block) => block &&
+            typeof block === "object" &&
+            Reflect.get(block, "type") === "text" &&
+            typeof Reflect.get(block, "text") === "string"
+            ? [Reflect.get(block, "text")]
+            : [])
+            .join("\n")
+        : "";
+}
+function stripExtension(filePath) {
+    const extension = extname(filePath);
+    return extension ? filePath.slice(0, -extension.length) : filePath;
+}
+export async function readActiveOmpEntryChain(sessionFile, activeEntryId) {
+    const content = await readFile(sessionFile, "utf8");
+    const entries = content.split("\n").flatMap((line) => {
+        if (!line.trim())
+            return [];
+        try {
+            const value = JSON.parse(line);
+            return value && typeof value === "object" && typeof value.id === "string" ? [value] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+    if (entries.length === 0)
+        return [];
+    const byId = new Map(entries.map((entry) => [entry.id, entry]));
+    const parentIds = new Set(entries.flatMap((entry) => (entry.parentId ? [entry.parentId] : [])));
+    const leaves = entries.filter((entry) => !parentIds.has(entry.id));
+    let current = (activeEntryId ? byId.get(activeEntryId) : undefined) ?? leaves.at(-1) ?? entries.at(-1);
+    const chain = [];
+    const seen = new Set();
+    while (current?.id && !seen.has(current.id)) {
+        chain.push(current);
+        seen.add(current.id);
+        current = current.parentId ? byId.get(current.parentId) : undefined;
+    }
+    return chain.toReversed();
+}
+function mapEntryMessage(entry) {
+    const message = entry.message;
+    if (message && typeof message.role === "string") {
+        if (message.role === "system") {
+            return null;
+        }
+        if (["user", "assistant", "toolResult", "custom", "bashExecution"].includes(message.role)) {
+            return message;
+        }
+        return visibleFallback(message.role, message);
+    }
+    if (!entry.type || isControlEntryType(entry.type)) {
+        return null;
+    }
+    return visibleFallback(entry.type, entry);
+}
+function isControlEntryType(type) {
+    return (type === "session" ||
+        type === "session_init" ||
+        type === "system" ||
+        type === "title" ||
+        type === "title_change" ||
+        type === "custom" ||
+        type === "system_prompt" ||
+        type === "model_change" ||
+        type === "thinking_level_change" ||
+        type === "tool_execution" ||
+        type.startsWith("tool_execution_"));
+}
+function visibleFallback(role, value) {
+    let text = "Unsupported history record";
+    if (typeof value.content === "string") {
+        text = value.content;
+    }
+    else if (typeof value.text === "string") {
+        text = value.text;
+    }
+    return { role: "custom", content: `[${role}] ${text}` };
+}
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    return content
+        .flatMap((part) => part && typeof part === "object" && typeof part.text === "string"
+        ? [part.text]
+        : [])
+        .join("\n");
+}
+//# sourceMappingURL=history.js.map

package/dist/server/server/agent/providers/omp/host-tools.d.ts

@@ -0,0 +1,14 @@
+import type { Logger } from "pino";
+import type { PaseoToolCatalog } from "../../tools/types.js";
+import type { OmpRuntimeSession } from "./runtime.js";
+import { type OmpRpcHostToolDefinition } from "./rpc-types.js";
+export declare function serializeOmpHostTools(catalog: PaseoToolCatalog): OmpRpcHostToolDefinition[];
+export declare function setOmpHostTools(runtimeSession: OmpRuntimeSession, catalog: PaseoToolCatalog): Promise<string[]>;
+export declare function handleOmpHostToolRuntimeEvent(event: unknown, input: {
+    runtimeSession: OmpRuntimeSession;
+    paseoTools?: PaseoToolCatalog;
+    logger: Logger;
+}): boolean;
+export declare function clearOmpHostToolState(runtimeSession: OmpRuntimeSession): void;
+export declare function waitForOmpHostToolsIdle(runtimeSession: OmpRuntimeSession): Promise<void>;
+//# sourceMappingURL=host-tools.d.ts.map

package/dist/server/server/agent/providers/omp/host-tools.js

@@ -0,0 +1,196 @@
+import { addModelVisibleStructuredContent, serializePaseoToolInputParameters, } from "../../tools/paseo-tool-serialization.js";
+import { OmpRpcHostToolCallRequestSchema, OmpRpcHostToolCancelRequestSchema, OmpRpcHostToolUpdateSchema, } from "./rpc-types.js";
+const routersByRuntimeSession = new WeakMap();
+export function serializeOmpHostTools(catalog) {
+    return [...catalog.tools.values()].map((tool) => {
+        const definition = {
+            name: tool.name,
+            description: tool.description,
+            loadMode: "essential",
+            parameters: serializePaseoToolInputParameters(tool),
+        };
+        if (tool.title) {
+            definition.label = tool.title;
+        }
+        return definition;
+    });
+}
+export async function setOmpHostTools(runtimeSession, catalog) {
+    return await runtimeSession.setHostTools(serializeOmpHostTools(catalog));
+}
+export function handleOmpHostToolRuntimeEvent(event, input) {
+    if (!isRecord(event) || typeof event.type !== "string" || !isOmpHostToolEventType(event.type)) {
+        return false;
+    }
+    const call = OmpRpcHostToolCallRequestSchema.safeParse(event);
+    if (call.success) {
+        const router = getRouter(input);
+        if (!router) {
+            sendMissingCatalogResult(input.runtimeSession, call.data);
+            return true;
+        }
+        router.handleCall(call.data);
+        return true;
+    }
+    const cancel = OmpRpcHostToolCancelRequestSchema.safeParse(event);
+    if (cancel.success) {
+        getRouter(input)?.handleCancel(cancel.data.targetId);
+        return true;
+    }
+    const update = OmpRpcHostToolUpdateSchema.safeParse(event);
+    if (update.success) {
+        input.logger.debug({ id: update.data.id }, "Ignoring unexpected inbound OMP host tool update");
+        return true;
+    }
+    input.logger.debug({ event }, "Dropped malformed OMP host tool frame");
+    return true;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function clearOmpHostToolState(runtimeSession) {
+    routersByRuntimeSession.get(runtimeSession)?.clear();
+    routersByRuntimeSession.delete(runtimeSession);
+}
+export async function waitForOmpHostToolsIdle(runtimeSession) {
+    await routersByRuntimeSession.get(runtimeSession)?.waitForIdle();
+}
+function getRouter(input) {
+    if (!input.paseoTools) {
+        return null;
+    }
+    const existing = routersByRuntimeSession.get(input.runtimeSession);
+    if (existing) {
+        return existing;
+    }
+    const router = new OmpHostToolRouter({
+        runtimeSession: input.runtimeSession,
+        catalog: input.paseoTools,
+        logger: input.logger,
+    });
+    routersByRuntimeSession.set(input.runtimeSession, router);
+    return router;
+}
+function sendMissingCatalogResult(runtimeSession, request) {
+    runtimeSession.sendHostToolResult(toOmpHostToolErrorResult(request.id, `Host tool "${request.toolName}" was called before Paseo tools were registered`));
+}
+function isOmpHostToolEventType(type) {
+    return type === "host_tool_call" || type === "host_tool_cancel" || type === "host_tool_update";
+}
+class OmpHostToolRouter {
+    constructor(input) {
+        this.pendingCalls = new Map();
+        this.idleWaiters = new Set();
+        this.runtimeSession = input.runtimeSession;
+        this.catalog = input.catalog;
+        this.logger = input.logger;
+    }
+    handleCall(request) {
+        const entry = {
+            controller: new AbortController(),
+            canceled: false,
+        };
+        this.pendingCalls.set(request.id, entry);
+        void this.executeCall(request, entry).catch((error) => {
+            this.logger.warn({ err: error, toolName: request.toolName }, "OMP host tool call failed");
+        });
+    }
+    handleCancel(targetId) {
+        const pending = this.pendingCalls.get(targetId);
+        if (!pending) {
+            return;
+        }
+        pending.canceled = true;
+        pending.controller.abort(new Error(`OMP host tool call ${targetId} cancelled`));
+    }
+    clear() {
+        for (const pending of this.pendingCalls.values()) {
+            pending.canceled = true;
+            pending.controller.abort(new Error("OMP session closed"));
+        }
+        this.pendingCalls.clear();
+        this.resolveIdleWaiters();
+    }
+    waitForIdle() {
+        if (this.pendingCalls.size === 0)
+            return Promise.resolve();
+        return new Promise((resolve) => this.idleWaiters.add(resolve));
+    }
+    async executeCall(request, entry) {
+        try {
+            const result = await this.catalog.executeTool(request.toolName, request.arguments, {
+                signal: entry.controller.signal,
+                sendUpdate: (update) => {
+                    if (entry.canceled || entry.controller.signal.aborted) {
+                        return;
+                    }
+                    this.sendUpdate(request.id, update);
+                },
+            });
+            if (entry.canceled || entry.controller.signal.aborted) {
+                return;
+            }
+            this.runtimeSession.sendHostToolResult(toOmpHostToolResult(request.id, result));
+        }
+        catch (error) {
+            if (entry.canceled || entry.controller.signal.aborted) {
+                return;
+            }
+            this.runtimeSession.sendHostToolResult(toOmpHostToolErrorResult(request.id, error));
+        }
+        finally {
+            this.pendingCalls.delete(request.id);
+            this.resolveIdleWaiters();
+        }
+    }
+    resolveIdleWaiters() {
+        if (this.pendingCalls.size > 0)
+            return;
+        for (const resolve of this.idleWaiters)
+            resolve();
+        this.idleWaiters.clear();
+    }
+    sendUpdate(callId, result) {
+        const update = {
+            type: "host_tool_update",
+            id: callId,
+            partialResult: toOmpAgentToolResult(addModelVisibleStructuredContent(result)),
+        };
+        this.runtimeSession.sendHostToolUpdate(update);
+    }
+}
+function toOmpHostToolResult(id, result) {
+    const modelVisibleResult = addModelVisibleStructuredContent(result);
+    const mappedResult = toOmpAgentToolResult(modelVisibleResult);
+    return {
+        type: "host_tool_result",
+        id,
+        result: mappedResult,
+        ...(modelVisibleResult.isError !== undefined ? { isError: modelVisibleResult.isError } : {}),
+    };
+}
+function toOmpHostToolErrorResult(id, error) {
+    return {
+        type: "host_tool_result",
+        id,
+        result: {
+            content: [{ type: "text", text: error instanceof Error ? error.message : String(error) }],
+            details: {},
+            isError: true,
+        },
+        isError: true,
+    };
+}
+function toOmpAgentToolResult(result) {
+    const mapped = {
+        content: result.content.map((item) => ({ ...item })),
+    };
+    if (result.structuredContent !== undefined) {
+        mapped.details = result.structuredContent;
+    }
+    if (result.isError !== undefined) {
+        mapped.isError = result.isError;
+    }
+    return mapped;
+}
+//# sourceMappingURL=host-tools.js.map

package/dist/server/server/agent/providers/omp/map-omp-model.d.ts

@@ -0,0 +1,11 @@
+import type { AgentModelDefinition, AgentProvider } from "../../agent-sdk-types.js";
+import type { OmpModel, OmpThinkingLevel } from "./rpc-types.js";
+export declare const DEFAULT_OMP_THINKING_LEVEL: OmpThinkingLevel;
+export declare const OMP_THINKING_OPTIONS: ReadonlyArray<{
+    id: OmpThinkingLevel;
+    label: string;
+    description: string;
+    isDefault?: boolean;
+}>;
+export declare function mapOmpModel(model: OmpModel, provider: AgentProvider): AgentModelDefinition;
+//# sourceMappingURL=map-omp-model.d.ts.map

package/dist/server/server/agent/providers/omp/map-omp-model.js

@@ -0,0 +1,67 @@
+export const DEFAULT_OMP_THINKING_LEVEL = "medium";
+export const OMP_THINKING_OPTIONS = [
+    { id: "off", label: "Off", description: "No extra reasoning" },
+    { id: "minimal", label: "Minimal", description: "Light reasoning" },
+    { id: "low", label: "Low", description: "Faster reasoning" },
+    { id: "medium", label: "Medium", description: "Balanced reasoning", isDefault: true },
+    { id: "high", label: "High", description: "Deeper reasoning" },
+    { id: "xhigh", label: "XHigh", description: "Extra-high reasoning" },
+    { id: "max", label: "Max", description: "Maximum reasoning" },
+];
+function mapThinkingOption(option, isDefault) {
+    const mapped = {
+        id: option.id,
+        label: option.label,
+        description: option.description,
+    };
+    if (isDefault ?? option.isDefault) {
+        mapped.isDefault = true;
+    }
+    return mapped;
+}
+export function mapOmpModel(model, provider) {
+    const { thinkingOptions, defaultThinkingOptionId } = resolveOmpThinkingConfig(model);
+    return {
+        provider,
+        id: `${model.provider}/${model.id}`,
+        label: `${model.provider}/${model.name ?? model.id}`,
+        description: `${model.provider}/${model.id}`,
+        metadata: {
+            provider: model.provider,
+            modelId: model.id,
+        },
+        thinkingOptions,
+        defaultThinkingOptionId,
+    };
+}
+function resolveOmpThinkingConfig(model) {
+    if (!model.reasoning) {
+        return { thinkingOptions: undefined, defaultThinkingOptionId: undefined };
+    }
+    const efforts = model.thinking?.efforts;
+    if (!efforts || efforts.length === 0) {
+        // Older omp versions don't report per-model thinking config; expose the full set.
+        return {
+            thinkingOptions: OMP_THINKING_OPTIONS.map((option) => mapThinkingOption(option)),
+            defaultThinkingOptionId: DEFAULT_OMP_THINKING_LEVEL,
+        };
+    }
+    const effortSet = new Set(efforts);
+    const filtered = OMP_THINKING_OPTIONS.filter((option) => effortSet.has(option.id));
+    if (filtered.length === 0) {
+        // All reported efforts are unrecognized; fall back to the full set with the standard default.
+        return {
+            thinkingOptions: OMP_THINKING_OPTIONS.map((option) => mapThinkingOption(option)),
+            defaultThinkingOptionId: DEFAULT_OMP_THINKING_LEVEL,
+        };
+    }
+    const reportedDefault = model.thinking?.defaultLevel;
+    const defaultThinkingOptionId = reportedDefault && filtered.some((option) => option.id === reportedDefault)
+        ? reportedDefault
+        : (filtered[0]?.id ?? DEFAULT_OMP_THINKING_LEVEL);
+    return {
+        thinkingOptions: filtered.map((option) => mapThinkingOption(option, option.id === defaultThinkingOptionId)),
+        defaultThinkingOptionId,
+    };
+}
+//# sourceMappingURL=map-omp-model.js.map

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

@@ -0,0 +1,38 @@
+import type { AgentStreamEvent, ToolCallDetail } from "../../agent-sdk-types.js";
+import type { OmpAgentMessage, OmpImageContent, OmpTextContent } from "./rpc-types.js";
+import { type OmpToolResult, type OmpTrackedToolCall } from "./tool-call-detail.js";
+export interface OmpCapturedUserMessageEntry {
+    id: string;
+    text: string;
+}
+export interface OmpHistoryMapperHooks {
+    mapCustomMessage?: (message: Extract<OmpAgentMessage, {
+        role: "custom";
+    }>, text: string, provider: string) => Extract<AgentStreamEvent, {
+        type: "timeline";
+    }> | null;
+    resolveToolCallId?: (toolCallId: string, toolCall: OmpTrackedToolCall) => string;
+    mapToolDetail?: (toolCall: OmpTrackedToolCall, result: OmpToolResult, context: {
+        toolCallId: string;
+    }) => ToolCallDetail | null;
+}
+export declare function getUserMessageText(content: string | (OmpTextContent | OmpImageContent)[]): string;
+export declare class OmpHistoryMapper {
+    private readonly provider;
+    private readonly userEntries;
+    private readonly hooks;
+    private readonly pendingToolCalls;
+    private userIndex;
+    private assistantIndex;
+    constructor(provider: string, userEntries?: readonly OmpCapturedUserMessageEntry[], hooks?: OmpHistoryMapperHooks);
+    mapMessages(messages: readonly OmpAgentMessage[]): AgentStreamEvent[];
+    private mapUserMessage;
+    private mapCustomMessage;
+    private mapAssistantMessage;
+    private mapToolResultMessage;
+    private mapBashExecutionMessage;
+    private resolveToolCallId;
+    private mapToolDetail;
+}
+export declare function streamOmpCoreHistory(provider: string, messages: OmpAgentMessage[], userEntries?: readonly OmpCapturedUserMessageEntry[], hooks?: OmpHistoryMapperHooks): AsyncGenerator<AgentStreamEvent>;
+//# sourceMappingURL=message-history.d.ts.map