@hyperdrive.bot/paseo-server 0.2.6

package/dist/server/server/agent/agent-storage.d.ts

@@ -0,0 +1,152 @@
+import { z } from "zod";
+import type { Logger } from "pino";
+import { type SessionDigest } from "../messages.js";
+import type { ManagedAgent } from "./agent-manager.js";
+import type { AgentSessionConfig } from "./agent-sdk-types.js";
+declare const STORED_AGENT_SCHEMA: z.ZodObject<{
+    id: z.ZodString;
+    provider: z.ZodString;
+    cwd: z.ZodString;
+    workspaceId: z.ZodOptional<z.ZodString>;
+    createdAt: z.ZodString;
+    updatedAt: z.ZodString;
+    lastActivityAt: z.ZodOptional<z.ZodString>;
+    lastUserMessageAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    title: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    labels: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    digest: z.ZodOptional<z.ZodObject<{
+        goal: z.ZodOptional<z.ZodString>;
+        nextStep: z.ZodOptional<z.ZodString>;
+        blockers: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            kind: z.ZodEnum<{
+                other: "other";
+                pr: "pr";
+                mr: "mr";
+                issue: "issue";
+                deploy: "deploy";
+                preview: "preview";
+                doc: "doc";
+            }>;
+            url: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>>>;
+        keyFiles: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        summary: z.ZodOptional<z.ZodString>;
+        accomplishments: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        selfReportedAt: z.ZodOptional<z.ZodString>;
+        generatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    lastStatus: z.ZodDefault<z.ZodEnum<{
+        error: "error";
+        initializing: "initializing";
+        idle: "idle";
+        running: "running";
+        closed: "closed";
+    }>>;
+    lastModeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    config: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        modeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        thinkingOptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        featureValues: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+        extra: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+        systemPrompt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        mcpServers: z.ZodOptional<z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodAny>>>;
+    }, z.core.$strip>>>;
+    runtimeInfo: z.ZodOptional<z.ZodObject<{
+        provider: z.ZodString;
+        sessionId: z.ZodNullable<z.ZodString>;
+        model: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        thinkingOptionId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        modeId: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+        extra: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>;
+    features: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"toggle">;
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        tooltip: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        value: z.ZodBoolean;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"select">;
+        id: z.ZodString;
+        label: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        tooltip: z.ZodOptional<z.ZodString>;
+        icon: z.ZodOptional<z.ZodString>;
+        value: z.ZodNullable<z.ZodString>;
+        options: z.ZodArray<z.ZodObject<{
+            id: z.ZodString;
+            label: z.ZodString;
+            description: z.ZodOptional<z.ZodString>;
+            isDefault: z.ZodOptional<z.ZodBoolean>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        }, z.core.$strip>>;
+    }, z.core.$strip>], "type">>>;
+    persistence: z.ZodOptional<z.ZodNullable<z.ZodObject<{
+        provider: z.ZodString;
+        sessionId: z.ZodString;
+        nativeHandle: z.ZodOptional<z.ZodAny>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodAny>>;
+    }, z.core.$strip>>>;
+    lastError: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    requiresAttention: z.ZodOptional<z.ZodBoolean>;
+    attentionReason: z.ZodOptional<z.ZodNullable<z.ZodEnum<{
+        finished: "finished";
+        error: "error";
+        permission: "permission";
+    }>>>;
+    attentionTimestamp: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    internal: z.ZodOptional<z.ZodBoolean>;
+    archivedAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>;
+export type SerializableAgentConfig = Pick<AgentSessionConfig, "modeId" | "model" | "thinkingOptionId" | "featureValues" | "extra" | "systemPrompt" | "mcpServers">;
+export type StoredAgentRecord = z.infer<typeof STORED_AGENT_SCHEMA>;
+export declare function parseStoredAgentRecord(value: unknown): StoredAgentRecord;
+export declare class AgentStorage {
+    private cache;
+    private pathById;
+    private pathsById;
+    private pendingWrites;
+    private deleting;
+    private loaded;
+    private baseDir;
+    private loadPromise;
+    private logger;
+    constructor(baseDir: string, logger: Logger);
+    initialize(): Promise<void>;
+    list(): Promise<StoredAgentRecord[]>;
+    get(agentId: string): Promise<StoredAgentRecord | null>;
+    upsert(record: StoredAgentRecord): Promise<void>;
+    private queueRecordWrite;
+    private writeRecord;
+    beginDelete(agentId: string): void;
+    remove(agentId: string): Promise<void>;
+    applySnapshot(agent: ManagedAgent, options?: {
+        title?: string | null;
+        internal?: boolean;
+    }): Promise<void>;
+    setTitle(agentId: string, title: string): Promise<void>;
+    setGeneratedTitle(agentId: string, title: string): Promise<StoredAgentRecord>;
+    /**
+     * Targeted digest-only update. Drains pending writes, reads the latest record,
+     * and updates ONLY the digest field — so an async digest refresh can never
+     * clobber a concurrent title/label write (which a full-record persist would).
+     * Mirrors setGeneratedTitle. See docs/session-digest.md §5.
+     */
+    setDigest(agentId: string, digest: SessionDigest): Promise<StoredAgentRecord>;
+    flush(): Promise<void>;
+    private load;
+    private doLoad;
+    private scanDisk;
+    private readRecordFile;
+    private buildRecordPath;
+    private addIndexedPath;
+    private removeIndexedPath;
+    private waitForPendingWrite;
+}
+export {};
+//# sourceMappingURL=agent-storage.d.ts.map

package/dist/server/server/agent/agent-storage.js

@@ -0,0 +1,342 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { writeJsonFileAtomic } from "../atomic-file.js";
+import { AgentFeatureSchema, AgentStatusSchema, SessionDigestSchema, } from "../messages.js";
+import { toStoredAgentRecord } from "./agent-projections.js";
+const SERIALIZABLE_CONFIG_SCHEMA = z
+    .object({
+    modeId: z.string().nullable().optional(),
+    model: z.string().nullable().optional(),
+    thinkingOptionId: z.string().nullable().optional(),
+    featureValues: z.record(z.string(), z.unknown()).nullable().optional(),
+    extra: z.record(z.string(), z.any()).nullable().optional(),
+    systemPrompt: z.string().nullable().optional(),
+    mcpServers: z.record(z.string(), z.any()).nullable().optional(),
+})
+    .nullable()
+    .optional();
+const PERSISTENCE_HANDLE_SCHEMA = z
+    .object({
+    provider: z.string(),
+    sessionId: z.string(),
+    nativeHandle: z.any().optional(),
+    metadata: z.record(z.string(), z.any()).optional(),
+})
+    .nullable()
+    .optional();
+const STORED_AGENT_SCHEMA = z.object({
+    id: z.string(),
+    provider: z.string(),
+    cwd: z.string(),
+    workspaceId: z.string().optional(),
+    createdAt: z.string(),
+    updatedAt: z.string(),
+    lastActivityAt: z.string().optional(),
+    lastUserMessageAt: z.string().nullable().optional(),
+    title: z.string().nullable().optional(),
+    labels: z.record(z.string(), z.string()).default({}),
+    // Session digest — structured per-session metadata for orchestrator triage.
+    // Optional → old records without it parse unchanged (no migration). See
+    // docs/session-digest.md.
+    digest: SessionDigestSchema.optional(),
+    lastStatus: AgentStatusSchema.default("closed"),
+    lastModeId: z.string().nullable().optional(),
+    config: SERIALIZABLE_CONFIG_SCHEMA,
+    runtimeInfo: z
+        .object({
+        provider: z.string(),
+        sessionId: z.string().nullable(),
+        model: z.string().nullable().optional(),
+        thinkingOptionId: z.string().nullable().optional(),
+        modeId: z.string().nullable().optional(),
+        extra: z.record(z.string(), z.unknown()).optional(),
+    })
+        .optional(),
+    features: z.array(AgentFeatureSchema).optional(),
+    persistence: PERSISTENCE_HANDLE_SCHEMA,
+    lastError: z.string().nullable().optional(),
+    requiresAttention: z.boolean().optional(),
+    attentionReason: z.enum(["finished", "error", "permission"]).nullable().optional(),
+    attentionTimestamp: z.string().nullable().optional(),
+    internal: z.boolean().optional(),
+    archivedAt: z.string().nullable().optional(),
+});
+export function parseStoredAgentRecord(value) {
+    return STORED_AGENT_SCHEMA.parse(value);
+}
+export class AgentStorage {
+    constructor(baseDir, logger) {
+        this.cache = new Map();
+        this.pathById = new Map();
+        this.pathsById = new Map();
+        this.pendingWrites = new Map();
+        this.deleting = new Set();
+        this.loaded = false;
+        this.loadPromise = null;
+        this.baseDir = baseDir;
+        this.logger = logger.child({ module: "agent", component: "agent-storage" });
+    }
+    async initialize() {
+        await this.load();
+    }
+    async list() {
+        await this.load();
+        return Array.from(this.cache.values());
+    }
+    async get(agentId) {
+        await this.load();
+        return this.cache.get(agentId) ?? null;
+    }
+    async upsert(record) {
+        await this.load();
+        await this.queueRecordWrite(record);
+    }
+    queueRecordWrite(record) {
+        const agentId = record.id;
+        const prev = this.pendingWrites.get(agentId) ?? Promise.resolve();
+        const next = prev.then(async () => {
+            if (this.deleting.has(agentId)) {
+                return undefined;
+            }
+            await this.writeRecord(record);
+            return undefined;
+        });
+        const tracked = next.finally(() => {
+            if (this.pendingWrites.get(agentId) === tracked) {
+                this.pendingWrites.delete(agentId);
+            }
+        });
+        this.pendingWrites.set(agentId, tracked);
+        return tracked;
+    }
+    async writeRecord(record) {
+        const agentId = record.id;
+        const nextPath = this.buildRecordPath(record);
+        const previousPath = this.pathById.get(agentId);
+        await writeJsonFileAtomic(nextPath, record);
+        this.addIndexedPath(agentId, nextPath);
+        if (previousPath && previousPath !== nextPath) {
+            try {
+                await fs.unlink(previousPath);
+            }
+            catch {
+                // ignore cleanup errors
+            }
+            this.removeIndexedPath(agentId, previousPath);
+        }
+        this.cache.set(agentId, record);
+        this.pathById.set(agentId, nextPath);
+    }
+    beginDelete(agentId) {
+        this.deleting.add(agentId);
+    }
+    async remove(agentId) {
+        await this.load();
+        this.beginDelete(agentId);
+        await (this.pendingWrites.get(agentId) ?? Promise.resolve());
+        const paths = Array.from(this.pathsById.get(agentId) ?? []);
+        await Promise.all(paths.map(async (filePath) => {
+            try {
+                await fs.unlink(filePath);
+            }
+            catch (error) {
+                const code = error.code;
+                if (code && code !== "ENOENT") {
+                    this.logger.warn({ err: error, agentId, filePath }, "Failed to remove agent record file");
+                }
+            }
+        }));
+        this.cache.delete(agentId);
+        this.pathById.delete(agentId);
+        this.pathsById.delete(agentId);
+    }
+    async applySnapshot(agent, options) {
+        await this.load();
+        await this.waitForPendingWrite(agent.id);
+        const existing = (await this.get(agent.id)) ?? null;
+        const hasTitleOverride = options !== undefined && Object.prototype.hasOwnProperty.call(options, "title");
+        const hasInternalOverride = options !== undefined && Object.prototype.hasOwnProperty.call(options, "internal");
+        const record = toStoredAgentRecord(agent, {
+            title: hasTitleOverride ? (options?.title ?? null) : (existing?.title ?? null),
+            createdAt: existing?.createdAt,
+            internal: hasInternalOverride ? options?.internal : (agent.internal ?? existing?.internal),
+        });
+        // Preserve soft-delete/archive status across snapshot flushes.
+        // `archivedAt` is not part of the ManagedAgent snapshot, so a naive projection
+        // would wipe it during normal persistence (including on daemon restart).
+        if (existing && existing.archivedAt !== undefined) {
+            record.archivedAt = existing.archivedAt;
+        }
+        await this.upsert(record);
+    }
+    async setTitle(agentId, title) {
+        await this.load();
+        await this.waitForPendingWrite(agentId);
+        const record = await this.get(agentId);
+        if (!record) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        await this.upsert({ ...record, title });
+    }
+    async setGeneratedTitle(agentId, title) {
+        await this.load();
+        await this.waitForPendingWrite(agentId);
+        const record = this.cache.get(agentId) ?? null;
+        if (!record) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        const nextRecord = {
+            ...record,
+            title,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.queueRecordWrite(nextRecord);
+        return nextRecord;
+    }
+    /**
+     * Targeted digest-only update. Drains pending writes, reads the latest record,
+     * and updates ONLY the digest field — so an async digest refresh can never
+     * clobber a concurrent title/label write (which a full-record persist would).
+     * Mirrors setGeneratedTitle. See docs/session-digest.md §5.
+     */
+    async setDigest(agentId, digest) {
+        await this.load();
+        await this.waitForPendingWrite(agentId);
+        const record = this.cache.get(agentId) ?? null;
+        if (!record) {
+            throw new Error(`Agent ${agentId} not found`);
+        }
+        const nextRecord = {
+            ...record,
+            digest,
+            updatedAt: new Date().toISOString(),
+        };
+        await this.queueRecordWrite(nextRecord);
+        return nextRecord;
+    }
+    async flush() {
+        await this.load().catch(() => undefined);
+        const writes = Array.from(this.pendingWrites.values());
+        await Promise.allSettled(writes);
+    }
+    async load() {
+        if (this.loaded) {
+            return Array.from(this.cache.values());
+        }
+        if (!this.loadPromise) {
+            this.loadPromise = this.doLoad();
+        }
+        return this.loadPromise;
+    }
+    async doLoad() {
+        this.cache.clear();
+        this.pathById.clear();
+        this.pathsById.clear();
+        try {
+            const records = await this.scanDisk();
+            this.loaded = true;
+            return records;
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                this.loaded = true;
+                return [];
+            }
+            this.logger.error({ err: error }, "Failed to load agents");
+            this.loaded = true;
+            return [];
+        }
+    }
+    async scanDisk() {
+        const records = [];
+        let entries = [];
+        try {
+            entries = await fs.readdir(this.baseDir, { withFileTypes: true });
+        }
+        catch (error) {
+            if (error.code === "ENOENT") {
+                return [];
+            }
+            throw error;
+        }
+        const rootRecordPaths = entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith(".json"))
+            .map((entry) => path.join(this.baseDir, entry.name));
+        const projectDirs = entries
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => path.join(this.baseDir, entry.name));
+        const projectFileLists = await Promise.all(projectDirs.map(async (projectDir) => {
+            try {
+                const files = await fs.readdir(projectDir, { withFileTypes: true });
+                return files
+                    .filter((file) => file.isFile() && file.name.endsWith(".json"))
+                    .map((file) => path.join(projectDir, file.name));
+            }
+            catch {
+                return [];
+            }
+        }));
+        const allFilePaths = [...rootRecordPaths, ...projectFileLists.flat()];
+        const loaded = await Promise.all(allFilePaths.map(async (filePath) => {
+            const record = await this.readRecordFile(filePath);
+            return record ? { record, filePath } : null;
+        }));
+        for (const item of loaded) {
+            if (!item)
+                continue;
+            const { record, filePath } = item;
+            records.push(record);
+            this.cache.set(record.id, record);
+            this.pathById.set(record.id, filePath);
+            this.addIndexedPath(record.id, filePath);
+        }
+        return records;
+    }
+    async readRecordFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, "utf8");
+            const parsed = JSON.parse(content);
+            return parseStoredAgentRecord(parsed);
+        }
+        catch (error) {
+            this.logger.error({ err: error, filePath }, "Skipping invalid agent record");
+            return null;
+        }
+    }
+    buildRecordPath(record) {
+        const projectDir = projectDirNameFromCwd(record.cwd);
+        return path.join(this.baseDir, projectDir, `${record.id}.json`);
+    }
+    addIndexedPath(agentId, filePath) {
+        const paths = this.pathsById.get(agentId) ?? new Set();
+        paths.add(filePath);
+        this.pathsById.set(agentId, paths);
+    }
+    removeIndexedPath(agentId, filePath) {
+        const paths = this.pathsById.get(agentId);
+        if (!paths) {
+            return;
+        }
+        paths.delete(filePath);
+        if (paths.size === 0) {
+            this.pathsById.delete(agentId);
+        }
+    }
+    async waitForPendingWrite(agentId) {
+        await (this.pendingWrites.get(agentId) ?? Promise.resolve()).catch(() => undefined);
+    }
+}
+function projectDirNameFromCwd(cwd) {
+    // path.win32.parse handles drive letters, UNC roots, and Unix roots on all platforms
+    const { root } = path.win32.parse(cwd);
+    const withoutRoot = cwd.slice(root.length).replace(/[\\/]+$/, "");
+    // Sanitize root: strip colons and separators, keep letters (e.g. "C:\" → "C", "\\server\share\" → "server-share")
+    const sanitizedRoot = root.replace(/[:\\/]+/g, "-").replace(/^-+|-+$/g, "");
+    const prefix = sanitizedRoot ? sanitizedRoot + "-" : "";
+    if (!withoutRoot) {
+        return sanitizedRoot || "root";
+    }
+    return prefix + withoutRoot.replace(/[\\/]+/g, "-");
+}
+//# sourceMappingURL=agent-storage.js.map

package/dist/server/server/agent/agent-stream-coalescer.d.ts

@@ -0,0 +1,41 @@
+import type { AgentProvider, AgentStreamEvent, AgentTimelineItem } from "./agent-sdk-types.js";
+export declare const AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS = 60;
+type CoalescableTextKind = "assistant_message" | "reasoning";
+type CoalescableTimelineKind = CoalescableTextKind | "tool_call";
+type CoalescableTimelineItem = Extract<AgentTimelineItem, {
+    type: CoalescableTimelineKind;
+}>;
+export interface AgentStreamCoalescerTimers {
+    setTimeout: (callback: () => void, ms?: number) => ReturnType<typeof setTimeout>;
+    clearTimeout: typeof clearTimeout;
+}
+export interface AgentStreamCoalescerFlush {
+    agentId: string;
+    item: CoalescableTimelineItem;
+    provider: AgentProvider;
+    turnId?: string;
+}
+export interface AgentStreamCoalescerOptions {
+    windowMs?: number;
+    timers: AgentStreamCoalescerTimers;
+    onFlush: (payload: AgentStreamCoalescerFlush) => void;
+}
+export declare class AgentStreamCoalescer {
+    private readonly buffers;
+    private readonly onFlush;
+    private readonly timers;
+    private readonly windowMs;
+    constructor(options: AgentStreamCoalescerOptions);
+    handle(agentId: string, event: AgentStreamEvent): boolean;
+    flushFor(agentId: string): void;
+    flushAll(): void;
+    flushAndDiscard(agentId: string): void;
+    private getOrCreateBuffer;
+    private appendToBuffer;
+    private scheduleFlush;
+    private clearTimer;
+    private flushBuffer;
+    private collapseEntries;
+}
+export {};
+//# sourceMappingURL=agent-stream-coalescer.d.ts.map

package/dist/server/server/agent/agent-stream-coalescer.js

@@ -0,0 +1,166 @@
+export const AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS = 60;
+function isCoalescableTimelineEvent(event) {
+    return (event.type === "timeline" &&
+        (event.item.type === "assistant_message" ||
+            event.item.type === "reasoning" ||
+            event.item.type === "tool_call"));
+}
+function isTextTimelineItem(item) {
+    return item.type === "assistant_message" || item.type === "reasoning";
+}
+function isTerminalToolCall(item) {
+    return (item.type === "tool_call" &&
+        (item.status === "completed" || item.status === "failed" || item.status === "canceled"));
+}
+export class AgentStreamCoalescer {
+    constructor(options) {
+        this.buffers = new Map();
+        this.windowMs = options.windowMs ?? AGENT_STREAM_COALESCE_DEFAULT_WINDOW_MS;
+        this.timers = options.timers;
+        this.onFlush = options.onFlush;
+    }
+    handle(agentId, event) {
+        if (!isCoalescableTimelineEvent(event)) {
+            return false;
+        }
+        if (isTextTimelineItem(event.item) && event.item.text === "") {
+            return true;
+        }
+        const buffer = this.getOrCreateBuffer(agentId);
+        this.appendToBuffer(buffer, event);
+        if (isTerminalToolCall(event.item)) {
+            this.flushBuffer(agentId);
+            return true;
+        }
+        if (!buffer.timer) {
+            this.scheduleFlush(buffer);
+        }
+        return true;
+    }
+    flushFor(agentId) {
+        this.flushBuffer(agentId);
+    }
+    flushAll() {
+        for (const agentId of Array.from(this.buffers.keys())) {
+            this.flushBuffer(agentId);
+        }
+    }
+    flushAndDiscard(agentId) {
+        this.flushBuffer(agentId);
+        const buffer = this.buffers.get(agentId);
+        if (buffer) {
+            this.clearTimer(buffer);
+            this.buffers.delete(agentId);
+        }
+    }
+    getOrCreateBuffer(agentId) {
+        const existing = this.buffers.get(agentId);
+        if (existing) {
+            return existing;
+        }
+        const buffer = {
+            agentId,
+            entries: [],
+            toolCallEntryIndexes: new Map(),
+            timer: null,
+            flushing: false,
+        };
+        this.buffers.set(agentId, buffer);
+        return buffer;
+    }
+    appendToBuffer(buffer, event) {
+        if (isTextTimelineItem(event.item)) {
+            buffer.entries.push({
+                kind: "text",
+                item: event.item,
+                text: event.item.text,
+                provider: event.provider,
+                ...(event.turnId !== undefined ? { turnId: event.turnId } : {}),
+            });
+            return;
+        }
+        const existingIndex = buffer.toolCallEntryIndexes.get(event.item.callId);
+        const entry = {
+            kind: "tool_call",
+            item: event.item,
+            provider: event.provider,
+            ...(event.turnId !== undefined ? { turnId: event.turnId } : {}),
+        };
+        if (existingIndex !== undefined) {
+            buffer.entries[existingIndex] = entry;
+            return;
+        }
+        buffer.toolCallEntryIndexes.set(event.item.callId, buffer.entries.length);
+        buffer.entries.push(entry);
+    }
+    scheduleFlush(buffer) {
+        const timer = this.timers.setTimeout(() => {
+            this.flushBuffer(buffer.agentId, buffer);
+        }, this.windowMs);
+        timer.unref?.();
+        buffer.timer = timer;
+    }
+    clearTimer(buffer) {
+        if (!buffer.timer) {
+            return;
+        }
+        this.timers.clearTimeout(buffer.timer);
+        buffer.timer = null;
+    }
+    flushBuffer(agentId, expectedBuffer) {
+        const buffer = this.buffers.get(agentId);
+        if (!buffer) {
+            return;
+        }
+        if (expectedBuffer && buffer !== expectedBuffer) {
+            return;
+        }
+        if (buffer.flushing) {
+            return;
+        }
+        this.clearTimer(buffer);
+        if (buffer.entries.length === 0) {
+            return;
+        }
+        const entries = buffer.entries;
+        buffer.entries = [];
+        buffer.toolCallEntryIndexes.clear();
+        buffer.flushing = true;
+        try {
+            for (const entry of this.collapseEntries(entries)) {
+                this.onFlush({
+                    agentId,
+                    item: entry.kind === "text"
+                        ? {
+                            ...entry.item,
+                            text: entry.text,
+                        }
+                        : entry.item,
+                    provider: entry.provider,
+                    ...(entry.turnId !== undefined ? { turnId: entry.turnId } : {}),
+                });
+            }
+        }
+        finally {
+            buffer.flushing = false;
+        }
+    }
+    collapseEntries(entries) {
+        const collapsed = [];
+        for (const entry of entries) {
+            const previous = collapsed.at(-1);
+            if (previous &&
+                previous.kind === "text" &&
+                entry.kind === "text" &&
+                previous.item.type === entry.item.type &&
+                previous.provider === entry.provider &&
+                previous.turnId === entry.turnId) {
+                previous.text += entry.text;
+                continue;
+            }
+            collapsed.push({ ...entry });
+        }
+        return collapsed;
+    }
+}
+//# sourceMappingURL=agent-stream-coalescer.js.map