@camerontaylor/paseo-server 0.8.0-fork.1

package/dist/server/server/agent/timeline-projection.d.ts

@@ -0,0 +1,74 @@
+import type { AgentTimelineItem } from "./agent-sdk-types.js";
+import type { AgentTimelineRow } from "./agent-manager.js";
+export type TimelineProjectionMode = "canonical" | "projected";
+export interface TimelineSeqRange {
+    startSeq: number;
+    endSeq: number;
+}
+export type TimelineProjectionKind = "assistant_merge" | "reasoning_merge" | "tool_lifecycle" | "identity";
+export type TimelineLimitDirection = "tail" | "before" | "after";
+export interface TimelineProjectionEntry {
+    item: AgentTimelineItem;
+    turnId?: string;
+    timestamp: string;
+    seqStart: number;
+    seqEnd: number;
+    sourceSeqRanges: TimelineSeqRange[];
+    collapsed: TimelineProjectionKind[];
+}
+interface ProjectedWindowSelection {
+    projectedEntries: TimelineProjectionEntry[];
+    selectedRows: AgentTimelineRow[];
+    minSeq: number | null;
+    maxSeq: number | null;
+}
+export interface ProjectedTimelinePageSelection {
+    entries: TimelineProjectionEntry[];
+    startSeq: number | null;
+    endSeq: number | null;
+    hasOlder: boolean;
+    hasNewer: boolean;
+}
+export declare function projectTimelineRows(input: {
+    rows: readonly AgentTimelineRow[];
+    mode: TimelineProjectionMode;
+}): TimelineProjectionEntry[];
+/**
+ * Select a timeline window based on projected-entry count, then map it back to
+ * contiguous canonical rows. This avoids cutting through merged assistant
+ * chunks when callers request canonical rows with a bounded limit.
+ */
+export declare function selectTimelineWindowByProjectedLimit(input: {
+    rows: readonly AgentTimelineRow[];
+    direction: TimelineLimitDirection;
+    limit: number;
+    projectedEntries?: TimelineProjectionEntry[];
+}): ProjectedWindowSelection;
+export declare function selectProjectedTimelinePage(input: {
+    rows: readonly AgentTimelineRow[];
+    bounds?: {
+        minSeq: number;
+        maxSeq: number;
+    };
+    direction: TimelineLimitDirection;
+    cursorSeq?: number;
+    limit?: number;
+    projectedEntries?: TimelineProjectionEntry[];
+}): ProjectedTimelinePageSelection;
+/**
+ * Apply a projected-count limit to a flat AgentTimelineItem[] without seq metadata.
+ * Used by callers that only have items in hand (e.g. MCP tools reading
+ * `agentManager.getTimeline`). Index position is treated as canonical seq.
+ */
+export interface ProjectedItemSelection {
+    items: AgentTimelineItem[];
+    totalProjected: number;
+    shownProjected: number;
+}
+export declare function selectItemsByProjectedLimit(input: {
+    items: readonly AgentTimelineItem[];
+    direction: TimelineLimitDirection;
+    limit: number;
+}): ProjectedItemSelection;
+export {};
+//# sourceMappingURL=timeline-projection.d.ts.map

package/dist/server/server/agent/timeline-projection.js

@@ -0,0 +1,467 @@
+import { timelineItemIdentity } from "@camerontaylor/paseo-protocol/timeline-identity";
+function appendSeqToRanges(ranges, seq) {
+    if (ranges.length === 0) {
+        return [{ startSeq: seq, endSeq: seq }];
+    }
+    const next = [...ranges];
+    const last = next[next.length - 1];
+    if (!last) {
+        return [{ startSeq: seq, endSeq: seq }];
+    }
+    if (seq <= last.endSeq + 1) {
+        last.endSeq = Math.max(last.endSeq, seq);
+        return next;
+    }
+    next.push({ startSeq: seq, endSeq: seq });
+    return next;
+}
+function mergeSeqRanges(existing, incoming) {
+    let merged = [...existing];
+    for (const range of incoming) {
+        for (let seq = range.startSeq; seq <= range.endSeq; seq += 1) {
+            merged = appendSeqToRanges(merged, seq);
+        }
+    }
+    return merged;
+}
+function mergeToolCallDetail(existing, incoming) {
+    if (existing.type === "unknown" && incoming.type !== "unknown") {
+        return incoming;
+    }
+    if (incoming.type === "unknown" && existing.type !== "unknown") {
+        return existing;
+    }
+    return incoming;
+}
+function mergeToolCallItems(existing, incoming) {
+    const mergedDetail = mergeToolCallDetail(existing.detail, incoming.detail);
+    const mergedMetadata = existing.metadata || incoming.metadata
+        ? { ...existing.metadata, ...incoming.metadata }
+        : undefined;
+    const merged = {
+        ...existing,
+        ...incoming,
+        detail: mergedDetail,
+        metadata: mergedMetadata,
+    };
+    if (incoming.status === "failed") {
+        merged.error = incoming.error;
+    }
+    else if (incoming.status === "completed" || incoming.status === "canceled") {
+        merged.error = null;
+    }
+    else if (incoming.error !== undefined) {
+        merged.error = incoming.error;
+    }
+    return merged;
+}
+function makeCanonicalEntries(rows) {
+    return rows.map((row) => ({
+        item: row.item,
+        ...(row.turnId ? { turnId: row.turnId } : {}),
+        timestamp: row.timestamp,
+        seqStart: row.seq,
+        seqEnd: row.seq,
+        sourceSeqRanges: [{ startSeq: row.seq, endSeq: row.seq }],
+        collapsed: [],
+    }));
+}
+function mergeIdentityMetadata(existing, entry, collapseKind) {
+    return {
+        sourceSeqRanges: mergeSeqRanges(existing.sourceSeqRanges, entry.sourceSeqRanges),
+        collapsed: existing.collapsed.includes(collapseKind)
+            ? existing.collapsed
+            : [...existing.collapsed, collapseKind],
+    };
+}
+function mergeIdentityEntries(existing, entry) {
+    switch (entry.item.type) {
+        case "tool_call":
+            if (existing.item.type !== "tool_call" || existing.turnId !== entry.turnId)
+                return null;
+            return {
+                ...existing,
+                item: mergeToolCallItems(existing.item, entry.item),
+                timestamp: entry.timestamp,
+                seqEnd: Math.max(existing.seqEnd, entry.seqEnd),
+                ...mergeIdentityMetadata(existing, entry, "tool_lifecycle"),
+            };
+        case "plugin":
+            if (existing.item.type !== "plugin")
+                return null;
+            return {
+                ...entry,
+                seqStart: existing.seqStart,
+                ...mergeIdentityMetadata(existing, entry, "identity"),
+            };
+        default:
+            return null;
+    }
+}
+function collapseByIdentity(entries) {
+    const output = [];
+    const indexByIdentity = new Map();
+    for (const entry of entries) {
+        const identity = timelineItemIdentity(entry.item);
+        if (identity === null) {
+            output.push(entry);
+            continue;
+        }
+        const existingIndex = indexByIdentity.get(identity);
+        if (existingIndex === undefined) {
+            indexByIdentity.set(identity, output.length);
+            output.push(entry);
+            continue;
+        }
+        const existing = output[existingIndex];
+        const merged = existing ? mergeIdentityEntries(existing, entry) : null;
+        if (!merged) {
+            indexByIdentity.set(identity, output.length);
+            output.push(entry);
+            continue;
+        }
+        output[existingIndex] = merged;
+    }
+    return output;
+}
+function mergeReasoningChunks(entries) {
+    const output = [];
+    for (const entry of entries) {
+        const previous = output[output.length - 1];
+        const shouldMerge = previous &&
+            previous.item.type === "reasoning" &&
+            entry.item.type === "reasoning" &&
+            previous.seqEnd + 1 === entry.seqStart &&
+            previous.turnId === entry.turnId;
+        if (!shouldMerge || !previous) {
+            output.push(entry);
+            continue;
+        }
+        const previousReasoning = previous.item;
+        const entryReasoning = entry.item;
+        const collapsedKinds = new Set([
+            ...previous.collapsed,
+            ...entry.collapsed,
+            "reasoning_merge",
+        ]);
+        output[output.length - 1] = {
+            ...previous,
+            item: {
+                type: "reasoning",
+                text: `${previousReasoning.text}${entryReasoning.text}`,
+            },
+            timestamp: entry.timestamp,
+            seqEnd: entry.seqEnd,
+            sourceSeqRanges: mergeSeqRanges(previous.sourceSeqRanges, entry.sourceSeqRanges),
+            collapsed: Array.from(collapsedKinds),
+        };
+    }
+    return output;
+}
+function mergeAssistantChunks(entries) {
+    const output = [];
+    for (const entry of entries) {
+        const previous = output[output.length - 1];
+        const shouldMerge = previous &&
+            previous.item.type === "assistant_message" &&
+            entry.item.type === "assistant_message" &&
+            previous.seqEnd + 1 === entry.seqStart &&
+            previous.turnId === entry.turnId;
+        if (!shouldMerge || !previous) {
+            output.push(entry);
+            continue;
+        }
+        const previousAssistant = previous.item;
+        const entryAssistant = entry.item;
+        if (entryAssistant.messageId !== undefined &&
+            previousAssistant.messageId !== entryAssistant.messageId) {
+            output.push(entry);
+            continue;
+        }
+        const collapsedKinds = new Set([
+            ...previous.collapsed,
+            ...entry.collapsed,
+            "assistant_merge",
+        ]);
+        output[output.length - 1] = {
+            ...previous,
+            item: {
+                type: "assistant_message",
+                text: `${previousAssistant.text}${entryAssistant.text}`,
+                ...(previousAssistant.messageId ? { messageId: previousAssistant.messageId } : {}),
+            },
+            timestamp: entry.timestamp,
+            seqEnd: entry.seqEnd,
+            sourceSeqRanges: mergeSeqRanges(previous.sourceSeqRanges, entry.sourceSeqRanges),
+            collapsed: Array.from(collapsedKinds),
+        };
+    }
+    return output;
+}
+export function projectTimelineRows(input) {
+    const canonical = makeCanonicalEntries(input.rows);
+    if (input.mode === "canonical") {
+        return canonical;
+    }
+    const toolCollapsed = collapseByIdentity(canonical);
+    const assistantMerged = mergeAssistantChunks(toolCollapsed);
+    return mergeReasoningChunks(assistantMerged);
+}
+/**
+ * Select a timeline window based on projected-entry count, then map it back to
+ * contiguous canonical rows. This avoids cutting through merged assistant
+ * chunks when callers request canonical rows with a bounded limit.
+ */
+export function selectTimelineWindowByProjectedLimit(input) {
+    const { rows, direction } = input;
+    const limit = Math.max(0, Math.floor(input.limit));
+    const projectedAll = input.projectedEntries ?? projectTimelineRows({ rows, mode: "projected" });
+    if (projectedAll.length === 0) {
+        return {
+            projectedEntries: [],
+            selectedRows: [],
+            minSeq: null,
+            maxSeq: null,
+        };
+    }
+    let windowEntries;
+    if (limit === 0 || limit >= projectedAll.length) {
+        windowEntries = projectedAll;
+    }
+    else if (direction === "after") {
+        windowEntries = projectedAll.slice(0, limit);
+    }
+    else {
+        windowEntries = projectedAll.slice(projectedAll.length - limit);
+    }
+    if (windowEntries.length === 0) {
+        return {
+            projectedEntries: [],
+            selectedRows: [],
+            minSeq: null,
+            maxSeq: null,
+        };
+    }
+    const computeWindowBounds = (entries) => {
+        let minSeq = Number.POSITIVE_INFINITY;
+        let maxSeq = Number.NEGATIVE_INFINITY;
+        for (const entry of entries) {
+            if (entry.seqStart < minSeq) {
+                minSeq = entry.seqStart;
+            }
+            if (entry.seqEnd > maxSeq) {
+                maxSeq = entry.seqEnd;
+            }
+        }
+        return { minSeq, maxSeq };
+    };
+    let { minSeq, maxSeq } = computeWindowBounds(windowEntries);
+    let expandedEntries = windowEntries;
+    // Expand to include any projected entries that overlap the selected canonical
+    // range. Tool lifecycle collapse can produce non-monotonic seqEnd values,
+    // which would otherwise create cursor gaps.
+    for (let iteration = 0; iteration < projectedAll.length + 1; iteration += 1) {
+        const overlapping = projectedAll.filter((entry) => entry.seqStart <= maxSeq && entry.seqEnd >= minSeq);
+        const nextBounds = computeWindowBounds(overlapping);
+        if (overlapping.length === expandedEntries.length &&
+            nextBounds.minSeq === minSeq &&
+            nextBounds.maxSeq === maxSeq) {
+            expandedEntries = overlapping;
+            break;
+        }
+        expandedEntries = overlapping;
+        minSeq = nextBounds.minSeq;
+        maxSeq = nextBounds.maxSeq;
+    }
+    const selectedRows = rows.filter((row) => row.seq >= minSeq && row.seq <= maxSeq);
+    return {
+        projectedEntries: expandedEntries,
+        selectedRows,
+        minSeq: Number.isFinite(minSeq) ? minSeq : null,
+        maxSeq: Number.isFinite(maxSeq) ? maxSeq : null,
+    };
+}
+function getTimelineBounds(rows) {
+    const first = rows[0];
+    const last = rows[rows.length - 1];
+    if (!first || !last) {
+        return null;
+    }
+    return { minSeq: first.seq, maxSeq: last.seq };
+}
+function firstSourceSeqInRange(entry, startSeq, endSeq) {
+    for (const range of entry.sourceSeqRanges) {
+        const firstSeq = Math.max(range.startSeq, startSeq);
+        if (firstSeq <= Math.min(range.endSeq, endSeq))
+            return firstSeq;
+    }
+    return null;
+}
+function selectProjectedEntriesAfter(input) {
+    const eligible = input.entries
+        .map((entry, index) => ({
+        entry,
+        index,
+        firstSourceSeq: firstSourceSeqInRange(entry, input.startSeq, input.maxSeq),
+    }))
+        .filter((candidate) => candidate.firstSourceSeq !== null)
+        .sort((left, right) => left.firstSourceSeq - right.firstSourceSeq || left.index - right.index);
+    const selected = input.limit === 0 ? eligible : eligible.slice(0, input.limit);
+    const selectedEntries = selected
+        .sort((left, right) => left.index - right.index)
+        .map((candidate) => candidate.entry);
+    if (selectedEntries.length === 0)
+        return { entries: [], endSeq: null };
+    const selectedRanges = selectedEntries
+        .flatMap((entry) => entry.sourceSeqRanges)
+        .sort((left, right) => left.startSeq - right.startSeq || left.endSeq - right.endSeq);
+    // Wide projected entries can include future, discontiguous source ranges. The
+    // page cursor advances only through source rows covered without a gap.
+    let endSeq = input.startSeq - 1;
+    let rangeIndex = 0;
+    for (const row of input.rows) {
+        if (row.seq < input.startSeq)
+            continue;
+        if (row.seq > input.maxSeq || row.seq !== endSeq + 1)
+            break;
+        while (selectedRanges[rangeIndex] && selectedRanges[rangeIndex].endSeq < row.seq) {
+            rangeIndex += 1;
+        }
+        const range = selectedRanges[rangeIndex];
+        if (!range || row.seq < range.startSeq || row.seq > range.endSeq)
+            break;
+        endSeq = row.seq;
+    }
+    return {
+        entries: selectedEntries,
+        endSeq: endSeq >= input.startSeq ? endSeq : null,
+    };
+}
+function selectProjectedEntriesBefore(input) {
+    // Older history follows projected display order. Lifecycle updates can move an
+    // entry's seqEnd without moving its display anchor, so seqStart keeps the full
+    // projected item on exactly one backward page.
+    const eligible = input.entries.filter((entry) => entry.seqStart <= input.endSeq);
+    const selected = input.limit === 0 || input.limit >= eligible.length
+        ? eligible
+        : eligible.slice(eligible.length - input.limit);
+    return {
+        entries: selected,
+        startSeq: selected[0]?.seqStart ?? null,
+        hasOlder: selected.length < eligible.length,
+    };
+}
+export function selectProjectedTimelinePage(input) {
+    const limit = input.limit === undefined ? 0 : Math.max(0, Math.floor(input.limit));
+    const bounds = input.bounds ?? getTimelineBounds(input.rows);
+    const projectedAll = input.projectedEntries ?? projectTimelineRows({ rows: input.rows, mode: "projected" });
+    if (!bounds) {
+        return {
+            entries: [],
+            startSeq: null,
+            endSeq: null,
+            hasOlder: false,
+            hasNewer: false,
+        };
+    }
+    if (projectedAll.length === 0) {
+        if (input.direction === "after") {
+            const cursorSeq = input.cursorSeq ?? bounds.minSeq - 1;
+            return {
+                entries: [],
+                startSeq: null,
+                endSeq: null,
+                hasOlder: cursorSeq >= bounds.minSeq,
+                hasNewer: cursorSeq < bounds.maxSeq,
+            };
+        }
+        if (input.direction === "before") {
+            const cursorSeq = input.cursorSeq ?? bounds.maxSeq + 1;
+            return {
+                entries: [],
+                startSeq: null,
+                endSeq: null,
+                hasOlder: cursorSeq > bounds.minSeq,
+                hasNewer: cursorSeq <= bounds.maxSeq,
+            };
+        }
+        return {
+            entries: [],
+            startSeq: null,
+            endSeq: null,
+            hasOlder: false,
+            hasNewer: false,
+        };
+    }
+    if (input.direction === "tail") {
+        const selected = selectTimelineWindowByProjectedLimit({
+            rows: input.rows,
+            direction: "tail",
+            limit,
+            projectedEntries: projectedAll,
+        });
+        return {
+            entries: selected.projectedEntries,
+            startSeq: selected.minSeq,
+            endSeq: selected.maxSeq,
+            hasOlder: selected.minSeq !== null && selected.minSeq > bounds.minSeq,
+            hasNewer: false,
+        };
+    }
+    if (input.direction === "after") {
+        const cursorSeq = input.cursorSeq ?? bounds.minSeq - 1;
+        const startSeq = Math.max(bounds.minSeq, cursorSeq + 1);
+        const selected = selectProjectedEntriesAfter({
+            entries: projectedAll,
+            rows: input.rows,
+            startSeq,
+            maxSeq: bounds.maxSeq,
+            limit,
+        });
+        return {
+            entries: selected.entries,
+            startSeq: selected.endSeq === null ? null : startSeq,
+            endSeq: selected.endSeq,
+            hasOlder: startSeq > bounds.minSeq,
+            hasNewer: selected.endSeq !== null && selected.endSeq < bounds.maxSeq,
+        };
+    }
+    const cursorSeq = input.cursorSeq ?? bounds.maxSeq + 1;
+    const endSeq = Math.min(bounds.maxSeq, cursorSeq - 1);
+    if (endSeq < bounds.minSeq) {
+        return {
+            entries: [],
+            startSeq: null,
+            endSeq: null,
+            hasOlder: false,
+            hasNewer: endSeq < bounds.maxSeq,
+        };
+    }
+    const selected = selectProjectedEntriesBefore({ entries: projectedAll, endSeq, limit });
+    return {
+        entries: selected.entries,
+        startSeq: selected.startSeq,
+        endSeq,
+        hasOlder: selected.hasOlder,
+        hasNewer: endSeq < bounds.maxSeq,
+    };
+}
+export function selectItemsByProjectedLimit(input) {
+    const rows = input.items.map((item, index) => ({
+        seq: index + 1,
+        timestamp: "",
+        item,
+    }));
+    const projectedAll = projectTimelineRows({ rows, mode: "projected" });
+    const window = selectTimelineWindowByProjectedLimit({
+        rows,
+        direction: input.direction,
+        limit: input.limit,
+    });
+    return {
+        items: window.selectedRows.map((row) => row.item),
+        totalProjected: projectedAll.length,
+        shownProjected: window.projectedEntries.length,
+    };
+}
+//# sourceMappingURL=timeline-projection.js.map

package/dist/server/server/agent/timeline-prompt-index.d.ts

@@ -0,0 +1,12 @@
+import type { AgentTimelineRow } from "./agent-timeline-store-types.js";
+export interface TimelinePromptIndexEntry {
+    seq: number;
+    timestamp: string;
+    preview: string;
+}
+export interface TimelinePromptIndex {
+    epoch: string;
+    prompts: TimelinePromptIndexEntry[];
+}
+export declare function buildTimelinePromptIndex(epoch: string, rows: readonly AgentTimelineRow[]): TimelinePromptIndex;
+//# sourceMappingURL=timeline-prompt-index.d.ts.map

package/dist/server/server/agent/timeline-prompt-index.js

@@ -0,0 +1,23 @@
+const PROMPT_PREVIEW_MAX_LENGTH = 120;
+function promptPreview(text) {
+    const collapsed = text.replace(/\s+/g, " ").trim();
+    if (collapsed.length <= PROMPT_PREVIEW_MAX_LENGTH) {
+        return collapsed;
+    }
+    return `${collapsed.slice(0, PROMPT_PREVIEW_MAX_LENGTH - 1)}…`;
+}
+export function buildTimelinePromptIndex(epoch, rows) {
+    return {
+        epoch,
+        prompts: rows.flatMap((row) => row.item.type === "user_message"
+            ? [
+                {
+                    seq: row.seq,
+                    timestamp: row.timestamp,
+                    preview: promptPreview(row.item.text),
+                },
+            ]
+            : []),
+    };
+}
+//# sourceMappingURL=timeline-prompt-index.js.map

package/dist/server/server/agent/tools/paseo-tool-serialization.d.ts

@@ -0,0 +1,4 @@
+import type { PaseoToolDefinition, PaseoToolResult } from "./types.js";
+export declare function addModelVisibleStructuredContent(result: PaseoToolResult): PaseoToolResult;
+export declare function serializePaseoToolInputParameters(tool: PaseoToolDefinition): Record<string, unknown>;
+//# sourceMappingURL=paseo-tool-serialization.d.ts.map

package/dist/server/server/agent/tools/paseo-tool-serialization.js

@@ -0,0 +1,58 @@
+// These SDK internals are reachable through @modelcontextprotocol/sdk's wildcard export,
+// not a curated public subpath. Keep that package pinned exactly and re-verify these
+// paths on every SDK bump so native host-tool schemas stay byte-compatible.
+import { normalizeObjectSchema, } from "@modelcontextprotocol/sdk/server/zod-compat.js";
+import { toJsonSchemaCompat } from "@modelcontextprotocol/sdk/server/zod-json-schema-compat.js";
+const EMPTY_OBJECT_JSON_SCHEMA = {
+    type: "object",
+    properties: {},
+};
+function formatStructuredContentForModel(structuredContent) {
+    if (!structuredContent ||
+        typeof structuredContent !== "object" ||
+        Array.isArray(structuredContent)) {
+        return JSON.stringify(structuredContent, null, 2);
+    }
+    const record = structuredContent;
+    const summary = [];
+    for (const [key, value] of Object.entries(record)) {
+        if (!Array.isArray(value)) {
+            continue;
+        }
+        summary.push(`${key}_count=${value.length}`);
+        const ids = value
+            .map((item) => item && typeof item === "object" && !Array.isArray(item)
+            ? item.id
+            : null)
+            .filter((id) => typeof id === "string" && id.length > 0);
+        if (ids.length === value.length && ids.length > 0) {
+            summary.push(`${key}_ids=${ids.join(",")}`);
+        }
+    }
+    const json = JSON.stringify(structuredContent, null, 2);
+    return summary.length > 0 ? `${summary.join("\n")}\n\n${json}` : json;
+}
+export function addModelVisibleStructuredContent(result) {
+    if (result.structuredContent === undefined || result.content.length > 0) {
+        return result;
+    }
+    return {
+        ...result,
+        content: [
+            {
+                type: "text",
+                text: formatStructuredContentForModel(result.structuredContent),
+            },
+        ],
+    };
+}
+export function serializePaseoToolInputParameters(tool) {
+    const schema = normalizeObjectSchema(tool.inputSchema);
+    return schema
+        ? toJsonSchemaCompat(schema, {
+            strictUnions: true,
+            pipeStrategy: "input",
+        })
+        : { ...EMPTY_OBJECT_JSON_SCHEMA };
+}
+//# sourceMappingURL=paseo-tool-serialization.js.map