@myagentroam/node 0.9.0 → 0.9.3

package/dist/runner-command-engine.js

@@ -8,7 +8,7 @@ const CLAUDE_PLAN_TAG_CLOSE = '</plan_mode>';
  */
 export function withClaudePlanTag(input) {
     return `${CLAUDE_PLAN_TAG_OPEN}
-当前处于 Plan Mode。只做只读分析与规划，不得创建、修改或删除文件，不得执行有副作用的命令。完成分析后，把最终计划完整包裹在 <proposed_plan> 与 </proposed_plan> 标签中输出，不要在标签外重复计划正文。
+You are in Plan Mode. Perform only read-only analysis and planning. Do not create, modify, or delete files, and do not run commands with side effects. Wrap the complete final plan in <proposed_plan> and </proposed_plan> tags without repeating the plan outside those tags.
 ${CLAUDE_PLAN_TAG_CLOSE}
 
 ${input}`;

package/dist/runner-profiles.js

@@ -1,3 +1,7 @@
+const COMMON_COMMAND_DESCRIPTIONS = {
+    compact: 'Compact the current session context.',
+    plan: 'Toggle collaborative Plan Mode.'
+};
 const CLAUDE_MODEL_ENVIRONMENT = {
     opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
     sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
@@ -14,24 +18,28 @@ const definitions = {
         runner: 'codex',
         models: [],
         accessOptions: [
-            { id: 'on-request', label: 'On-request', description: '由 Codex 在需要额外权限时请求确认。' },
+            {
+                id: 'on-request',
+                label: 'On-request',
+                description: 'Ask when additional permission is required.'
+            },
             {
                 id: 'workspace-write',
                 label: 'Workspace write',
-                description: '允许 Codex 在当前工作区内写入文件。'
+                description: 'Allow writes in the current Workspace.'
             },
             {
                 id: 'full-access',
                 label: 'Full access',
-                description: '允许 Codex 以完整权限运行，且不再逐项确认。'
+                description: 'Allow full access without individual confirmations.'
             },
-            { id: 'read-only', label: 'Read-only', description: '限制 Codex 为只读沙箱。' }
+            { id: 'read-only', label: 'Read-only', description: 'Restrict Codex to a read-only sandbox.' }
         ],
         commands: [
             {
                 id: 'compact',
                 label: '/compact',
-                description: '立即压缩当前会话上下文。',
+                description: COMMON_COMMAND_DESCRIPTIONS.compact,
                 inputHint: '/compact',
                 interaction: 'IMMEDIATE_ACTION'
             },
@@ -39,14 +47,14 @@ const definitions = {
                 id: 'plan',
                 label: '/plan',
                 stateLabel: 'Plan Mode',
-                description: '开启或关闭协作规划模式。',
+                description: COMMON_COMMAND_DESCRIPTIONS.plan,
                 inputHint: '/plan',
                 interaction: 'TOGGLE'
             },
             {
                 id: 'fast',
                 label: '/fast',
-                description: '开启或关闭当前模型可用的快速服务层。',
+                description: 'Toggle the fast service tier when supported.',
                 inputHint: '/fast',
                 interaction: 'TOGGLE'
             }
@@ -74,21 +82,25 @@ const definitions = {
             { id: 'haiku', label: 'Claude Haiku', supportedEfforts: ['low', 'medium'] }
         ],
         accessOptions: [
-            { id: 'default', label: 'Default', description: '按 Claude Code 默认规则确认危险操作。' },
+            { id: 'default', label: 'Default', description: 'Use Claude Code default confirmations.' },
             {
                 id: 'accept-edits',
                 label: 'Accept edits',
-                description: '自动接受当前工作区内的文件编辑。'
+                description: 'Automatically accept edits in the current Workspace.'
+            },
+            {
+                id: 'bypass',
+                label: 'Bypass permissions',
+                description: 'Bypass permission confirmations.'
             },
-            { id: 'bypass', label: 'Bypass permissions', description: '跳过 Claude Code 的权限确认。' },
-            { id: 'plan', label: 'Plan Mode', description: '以 Claude Code 的计划模式运行，不执行工具。' }
+            { id: 'plan', label: 'Plan Mode', description: 'Run in Plan Mode without executing tools.' }
         ],
         commands: [
             {
                 id: 'compact',
                 runner: 'claude-code',
                 label: '/compact',
-                description: '由 Claude Agent SDK 在当前会话中压缩上下文。',
+                description: COMMON_COMMAND_DESCRIPTIONS.compact,
                 inputHint: '/compact',
                 source: 'CLAUDE_AGENT_SDK',
                 interaction: 'IMMEDIATE_ACTION',
@@ -100,7 +112,7 @@ const definitions = {
                 runner: 'claude-code',
                 label: '/plan',
                 stateLabel: 'Plan Mode',
-                description: '开启或关闭标签式规划模式，只读规划并输出计划卡。',
+                description: COMMON_COMMAND_DESCRIPTIONS.plan,
                 inputHint: '/plan',
                 source: 'CLAUDE_AGENT_SDK',
                 interaction: 'TOGGLE',
@@ -116,12 +128,12 @@ const definitions = {
             {
                 id: 'default',
                 label: 'Default',
-                description: '按 OpenCode 和当前 Workspace 配置确认权限。'
+                description: 'Use OpenCode and Workspace permission configuration.'
             },
             {
                 id: 'auto',
                 label: 'Auto approve',
-                description: '自动允许 OpenCode 请求的工具权限。'
+                description: 'Automatically allow requested tool permissions.'
             }
         ],
         commands: [
@@ -129,7 +141,7 @@ const definitions = {
                 id: 'compact',
                 runner: 'opencode',
                 label: '/compact',
-                description: '通过 OpenCode 压缩当前会话上下文。',
+                description: COMMON_COMMAND_DESCRIPTIONS.compact,
                 inputHint: '/compact',
                 source: 'OPENCODE_SERVER',
                 interaction: 'IMMEDIATE_ACTION',
@@ -141,7 +153,7 @@ const definitions = {
                 runner: 'opencode',
                 label: '/plan',
                 stateLabel: 'Plan Mode',
-                description: '开启或关闭 OpenCode 原生 Plan Agent。',
+                description: COMMON_COMMAND_DESCRIPTIONS.plan,
                 inputHint: '/plan',
                 source: 'OPENCODE_SERVER',
                 interaction: 'TOGGLE',

package/dist/runner-usage.js

@@ -70,9 +70,9 @@ export class RunnerUsageReader {
             'Content-Type': 'application/json'
         });
         const windows = [
-            usageWindow(value, 'five_hour', '5 小时额度'),
-            usageWindow(value, 'seven_day', '7 天额度'),
-            usageWindow(value, 'seven_day_sonnet', '7 天 Sonnet 额度')
+            usageWindow(value, 'five_hour', '5-hour limit'),
+            usageWindow(value, 'seven_day', '7-day limit'),
+            usageWindow(value, 'seven_day_sonnet', '7-day Sonnet limit')
         ].filter((window) => window !== undefined);
         if (windows.length === 0)
             throw new Error('USAGE_RESPONSE_INVALID');
@@ -158,9 +158,9 @@ function codexUsageWindow(value, key) {
     const window = record(record(value)?.rate_limit)?.[key];
     const duration = number(record(window)?.limit_window_seconds);
     const label = duration !== undefined && approximately(duration, 5 * 60 * 60)
-        ? '5 小时额度'
+        ? '5-hour limit'
         : duration !== undefined && approximately(duration, 7 * 24 * 60 * 60)
-            ? '7 天额度'
+            ? '7-day limit'
             : undefined;
     return label === undefined ? undefined : usageWindow(value, key, label);
 }

package/dist/runtime-state.d.ts

@@ -1,5 +1,5 @@
 import type { AgentRunStatus, RunnerName } from '@myagentroam/protocol';
-import type { ConversationItemPage, ConversationPage, NativeSessionControl, NodeAgentRun, NodeAgentSession, NodeApproval, NodeConversationTurn, NodeMessageAttachmentInput, NodeRunEvent, NodeWorkspace, WorkspaceActivityPage } from './database.js';
+import type { ConversationItemPage, ConversationPage, NativeSessionControl, NodeAgentRun, NodeAgentSession, NodeApproval, NodeConversationTurn, NodeMessageAttachmentInput, NodeRunEvent, NodeWorkspace } from './database.js';
 /**
  * Deliberately process-local runtime domain.  No method in this class writes
  * into Node SQLite: a Node restart loses active runs, approvals, leases and
@@ -10,22 +10,22 @@ export declare class NodeRuntimeState {
     private readonly nodeId;
     private readonly getWorkspace;
     private readonly now;
+    private static readonly MAX_COMPLETED_TURNS_PER_SESSION;
     private readonly sessions;
     private readonly runs;
     private readonly messageRuns;
     private readonly events;
     private readonly turns;
     private readonly approvals;
-    private readonly workspaceEvents;
     /** A Session owns at most one running turn; Workspace sessions may run concurrently. */
     private readonly leases;
     /** Session FIFO metadata is deliberately process-local with the rest of run state. */
     private readonly queuedRuns;
     private readonly queueVersions;
     private readonly pausedQueues;
-    private readonly snapshots;
+    /** Bounded tombstones reject stale internal start envelopes after terminal cleanup. */
+    private readonly terminalRunIds;
     private nextEventId;
-    private nextWorkspaceEventId;
     constructor(nodeId: () => string, getWorkspace: (id: string) => NodeWorkspace | undefined, now?: () => number);
     activeWorkspaceLeaseCount(): number;
     activeSessionRun(sessionId: string): NodeAgentRun | undefined;
@@ -138,11 +138,6 @@ export declare class NodeRuntimeState {
         readonly outputPreview: string;
         readonly failed?: boolean;
     }): NodeConversationTurn;
-    listWorkspaceActivity(input: {
-        readonly workspaceId: string;
-        readonly cursor?: string;
-        readonly limit?: number;
-    }): WorkspaceActivityPage;
     createApproval(input: {
         readonly runId: string;
         readonly approvalId: string;
@@ -156,8 +151,7 @@ export declare class NodeRuntimeState {
     expireDueApprovals(): readonly NodeApproval[];
     listNonterminalRuns(): readonly NodeAgentRun[];
     lastRunSequence(id: string): number;
-    saveSnapshot(id: string, value: unknown): void;
-    getSnapshot(id: string): unknown | undefined;
+    removeTerminalRun(runId: string): void;
     hasActiveWorkspaceLease(workspaceId: string): boolean;
     /** Removes a terminal Session's process-local projection after its native history is deleted. */
     removeAgentSession(sessionId: string): void;
@@ -168,7 +162,6 @@ export declare class NodeRuntimeState {
     private requireSession;
     private requireRun;
     private requireApproval;
-    private recordWorkspaceActivity;
     private updateTurnForRun;
     private projectEvent;
 }

package/dist/runtime-state.js

@@ -9,22 +9,22 @@ export class NodeRuntimeState {
     nodeId;
     getWorkspace;
     now;
+    static MAX_COMPLETED_TURNS_PER_SESSION = 10;
     sessions = new Map();
     runs = new Map();
     messageRuns = new Map();
     events = new Map();
     turns = new Map();
     approvals = new Map();
-    workspaceEvents = new Map();
     /** A Session owns at most one running turn; Workspace sessions may run concurrently. */
     leases = new Map();
     /** Session FIFO metadata is deliberately process-local with the rest of run state. */
     queuedRuns = new Map();
     queueVersions = new Map();
     pausedQueues = new Set();
-    snapshots = new Map();
+    /** Bounded tombstones reject stale internal start envelopes after terminal cleanup. */
+    terminalRunIds = new Set();
     nextEventId = 1;
-    nextWorkspaceEventId = 1;
     constructor(nodeId, getWorkspace, now = Date.now) {
         this.nodeId = nodeId;
         this.getWorkspace = getWorkspace;
@@ -73,6 +73,8 @@ export class NodeRuntimeState {
     }
     /** Internal envelope compatibility for a Run already accepted in this process. */
     adoptRun(input) {
+        if (this.terminalRunIds.has(input.runId))
+            throw new Error('RUN_TERMINAL');
         let session = this.sessions.get(input.sessionId);
         if (session === undefined) {
             const now = this.now();
@@ -316,11 +318,6 @@ export class NodeRuntimeState {
         this.queuedRuns.set(session.id, [...(this.queuedRuns.get(session.id) ?? []), run.id]);
         this.bumpQueueVersion(session.id);
         this.turns.set(session.id, [...(this.turns.get(session.id) ?? []), fixedTurn]);
-        this.recordWorkspaceActivity(run.workspaceId, 'run.created', {
-            runId: run.id,
-            sessionId: session.id,
-            runner: run.runner
-        });
         this.replaceSession(session.id, { lastActivityAt: now });
         return { run, created: true };
     }
@@ -402,7 +399,6 @@ export class NodeRuntimeState {
         this.bumpQueueVersion(run.sessionId);
         this.runs.delete(runId);
         this.events.delete(runId);
-        this.snapshots.delete(runId);
         this.turns.set(run.sessionId, (this.turns.get(run.sessionId) ?? []).filter((turn) => turn.runId !== runId));
         for (const [key, candidate] of this.messageRuns)
             if (candidate === runId)
@@ -468,12 +464,6 @@ export class NodeRuntimeState {
         if (input.status !== undefined)
             this.transitionRun(input.runId, input.status);
         this.projectEvent(value);
-        const run = this.requireRun(input.runId);
-        this.recordWorkspaceActivity(run.workspaceId, 'run.updated', {
-            runId: run.id,
-            eventType: input.eventType,
-            status: input.status ?? null
-        });
         return value;
     }
     listRunEvents(id, after = 0) {
@@ -559,16 +549,6 @@ export class NodeRuntimeState {
         this.replaceSession(session.id, { lastActivityAt: now });
         return completedTurn;
     }
-    listWorkspaceActivity(input) {
-        const all = this.workspaceEvents.get(input.workspaceId) ?? [];
-        const start = decodeCursor(input.cursor, input.workspaceId);
-        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
-        const events = all.slice(start, start + limit);
-        return {
-            events,
-            nextCursor: start + limit < all.length ? encodeCursor(input.workspaceId, start + limit) : null
-        };
-    }
     createApproval(input) {
         this.requireRun(input.runId);
         if (this.approvals.has(input.approvalId))
@@ -631,11 +611,30 @@ export class NodeRuntimeState {
     lastRunSequence(id) {
         return this.events.get(id)?.at(-1)?.sequence ?? 0;
     }
-    saveSnapshot(id, value) {
-        this.snapshots.set(id, value);
-    }
-    getSnapshot(id) {
-        return this.snapshots.get(id);
+    removeTerminalRun(runId) {
+        const run = this.requireRun(runId);
+        if (!terminal(run.status))
+            throw new Error('RUN_ACTIVE');
+        this.terminalRunIds.add(runId);
+        if (this.terminalRunIds.size > 1_024)
+            this.terminalRunIds.delete(this.terminalRunIds.values().next().value);
+        const queue = this.queuedRuns.get(run.sessionId) ?? [];
+        if (queue.includes(runId)) {
+            this.queuedRuns.set(run.sessionId, queue.filter((candidate) => candidate !== runId));
+            this.bumpQueueVersion(run.sessionId);
+        }
+        this.runs.delete(runId);
+        this.events.delete(runId);
+        const turns = this.turns.get(run.sessionId) ?? [];
+        const completed = turns.filter((turn) => terminalTurn(turn.status));
+        const retainedCompleted = new Set(completed.slice(-NodeRuntimeState.MAX_COMPLETED_TURNS_PER_SESSION).map((turn) => turn.id));
+        this.turns.set(run.sessionId, turns.filter((turn) => !terminalTurn(turn.status) || retainedCompleted.has(turn.id)));
+        for (const [key, candidate] of this.messageRuns)
+            if (candidate === runId)
+                this.messageRuns.delete(key);
+        for (const [approvalId, approval] of this.approvals)
+            if (approval.runId === runId)
+                this.approvals.delete(approvalId);
     }
     hasActiveWorkspaceLease(workspaceId) {
         return [...this.leases.values()]
@@ -658,7 +657,6 @@ export class NodeRuntimeState {
         for (const runId of runIds) {
             this.runs.delete(runId);
             this.events.delete(runId);
-            this.snapshots.delete(runId);
         }
         for (const [key, runId] of this.messageRuns)
             if (runIds.has(runId))
@@ -681,7 +679,6 @@ export class NodeRuntimeState {
         for (const runId of runIds) {
             this.runs.delete(runId);
             this.events.delete(runId);
-            this.snapshots.delete(runId);
         }
         for (const [key, runId] of this.messageRuns)
             if (runIds.has(runId))
@@ -689,7 +686,6 @@ export class NodeRuntimeState {
         for (const [approvalId, approval] of this.approvals)
             if (runIds.has(approval.runId))
                 this.approvals.delete(approvalId);
-        this.workspaceEvents.delete(workspaceId);
         for (const sessionId of sessionIds) {
             this.queuedRuns.delete(sessionId);
             this.queueVersions.delete(sessionId);
@@ -730,19 +726,6 @@ export class NodeRuntimeState {
             throw new Error('APPROVAL_NOT_FOUND');
         return value;
     }
-    recordWorkspaceActivity(workspaceId, eventType, payload) {
-        const event = {
-            id: this.nextWorkspaceEventId++,
-            workspaceId,
-            eventType,
-            payload,
-            createdAt: this.now()
-        };
-        this.workspaceEvents.set(workspaceId, [
-            ...(this.workspaceEvents.get(workspaceId) ?? []),
-            event
-        ]);
-    }
     updateTurnForRun(runId, update) {
         const run = this.requireRun(runId);
         const current = this.turns.get(run.sessionId) ?? [];
@@ -840,6 +823,9 @@ export class NodeRuntimeState {
 function terminal(status) {
     return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED', 'LOST'].includes(status);
 }
+function terminalTurn(status) {
+    return ['SUCCEEDED', 'FAILED', 'CANCELLED', 'INTERRUPTED'].includes(status);
+}
 function transitionAllowed(from, to) {
     return !terminal(from) || from === to;
 }

package/dist/service/attachment-domain-state.d.ts

@@ -1,5 +1,7 @@
 export declare class AttachmentDomainState<TCachedRunImages, TNativeImageSource> {
     readonly runDirectories: Map<string, string>;
+    readonly runFileDirectories: Map<string, string>;
     readonly runImages: Map<string, TCachedRunImages>;
     readonly nativeHistoryImages: Map<string, TNativeImageSource[]>;
+    readonly nativeHistoryImageTimers: Map<string, NodeJS.Timeout>;
 }

package/dist/service/attachment-domain-state.js

@@ -1,5 +1,7 @@
 export class AttachmentDomainState {
     runDirectories = new Map();
+    runFileDirectories = new Map();
     runImages = new Map();
     nativeHistoryImages = new Map();
+    nativeHistoryImageTimers = new Map();
 }

package/dist/service/conversation-history-service.js

@@ -16,35 +16,66 @@ export class ConversationHistoryService {
     async read(session, input) {
         const snapshotSequence = this.options.snapshotSequence();
         const readAt = Date.now();
-        const official = await this.readOfficial(session, input);
+        let official = await this.readOfficial(session, input);
         if (official !== undefined) {
+            const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+            const runtimeTurns = this.options.runtime.getAgentSession(session.id) === undefined
+                ? []
+                : this.options.runtime.listConversationTurns({ sessionId: session.id, limit: 500 }).turns;
+            const initialOfficialRunIds = new Set(official.turns.flatMap((turn) => (turn.runId === null ? [] : [turn.runId])));
+            const absentLocalTurns = runtimeTurns.filter((turn) => turn.runId === null || !initialOfficialRunIds.has(turn.runId));
+            const officialFloor = Math.min(...official.turns.map((turn) => Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0)));
+            const missingLocalTurns = official.turns.length === 0
+                ? absentLocalTurns.slice(-limit)
+                : officialFloor > 0
+                    ? absentLocalTurns.filter((turn) => Math.max(turn.startedAt ?? 0, turn.completedAt ?? 0) >= officialFloor)
+                    : absentLocalTurns.slice(-1);
+            if (input.cursor === undefined &&
+                missingLocalTurns.length > 0 &&
+                official.turns.length + missingLocalTurns.length > limit) {
+                const reserved = Math.min(missingLocalTurns.length, Math.max(0, limit - 1));
+                const narrowed = await this.readOfficial(session, { ...input, limit: limit - reserved });
+                if (narrowed !== undefined)
+                    official = narrowed;
+            }
             const officialTurns = await this.attachNativeImages(session, official.turns);
             const officialRunIds = new Set(officialTurns.flatMap((turn) => (turn.runId === null ? [] : [turn.runId])));
-            const localTurns = this.options.runtime.getAgentSession(session.id) === undefined
-                ? []
-                : this.options.runtime
-                    .listConversationTurns({ sessionId: session.id, limit: 500 })
-                    .turns.flatMap((turn) => {
-                    if (turn.runId === null || !officialRunIds.has(turn.runId))
-                        return [turn];
-                    const pendingItems = turn.items.filter((item) => item.kind === 'user_input_request' && item.status === 'PENDING');
-                    return pendingItems.length === 0 ? [] : [{ ...turn, items: pendingItems }];
-                });
-            const localRequestIds = new Set(localTurns.flatMap((turn) => turn.items.flatMap((item) => {
-                const requestId = item.kind === 'user_input_request' && isPlainRecord(item.payload)
-                    ? item.payload.requestId
-                    : undefined;
-                return typeof requestId === 'string' ? [requestId] : [];
-            })));
+            const pendingItemsByRunId = new Map();
+            for (const turn of runtimeTurns) {
+                if (turn.runId === null || !officialRunIds.has(turn.runId))
+                    continue;
+                const pendingItems = turn.items.filter((item) => item.kind === 'user_input_request' && item.status === 'PENDING');
+                if (pendingItems.length > 0)
+                    pendingItemsByRunId.set(turn.runId, pendingItems);
+            }
+            const availableLocalSlots = Math.max(0, limit - officialTurns.length);
+            const localCandidates = (input.cursor === undefined ? missingLocalTurns : []).sort((left, right) => (left.startedAt ?? 0) - (right.startedAt ?? 0));
+            const localTurns = availableLocalSlots === 0 ? [] : localCandidates.slice(-availableLocalSlots);
+            const localRequestIds = new Set([
+                ...localTurns.flatMap((turn) => turn.items.flatMap((item) => {
+                    const requestId = item.kind === 'user_input_request' && isPlainRecord(item.payload)
+                        ? item.payload.requestId
+                        : undefined;
+                    return typeof requestId === 'string' ? [requestId] : [];
+                })),
+                ...[...pendingItemsByRunId.values()].flatMap((items) => items.flatMap((item) => {
+                    const requestId = isPlainRecord(item.payload) ? item.payload.requestId : undefined;
+                    return typeof requestId === 'string' ? [requestId] : [];
+                }))
+            ]);
             const turns = [
                 ...officialTurns
-                    .map((turn) => ({
-                    ...turn,
-                    items: turn.items.filter((item) => item.kind !== 'user_input_request' ||
-                        !isPlainRecord(item.payload) ||
-                        typeof item.payload.requestId !== 'string' ||
-                        !localRequestIds.has(item.payload.requestId))
-                }))
+                    .map((turn) => {
+                    const pendingItems = turn.runId === null ? [] : (pendingItemsByRunId.get(turn.runId) ?? []);
+                    const items = [
+                        ...turn.items.filter((item) => item.kind !== 'user_input_request' ||
+                            !isPlainRecord(item.payload) ||
+                            typeof item.payload.requestId !== 'string' ||
+                            !localRequestIds.has(item.payload.requestId)),
+                        ...pendingItems
+                    ];
+                    return { ...turn, items };
+                })
                     .filter((turn) => turn.items.length > 0),
                 ...localTurns
             ].sort((left, right) => (left.startedAt ?? 0) - (right.startedAt ?? 0));

package/dist/service/conversation-segment-service.d.ts

@@ -0,0 +1,20 @@
+import type { ConversationSegment, ConversationSegmentPage } from '@myagentroam/protocol';
+import type { NodeAgentSession, NodeConversationTurn } from '../database.js';
+import type { ConversationHistoryPage } from '../util/runner-native-session-parsers.js';
+export declare function conversationSegments(turn: NodeConversationTurn): ConversationSegment[];
+export declare function conversationSegmentIdentityForItem(turn: NodeConversationTurn, itemId: string, itemKind?: string): {
+    readonly id: string;
+    readonly index: number;
+};
+export declare class ConversationSegmentService {
+    private readonly readTurns;
+    constructor(readTurns: (session: NodeAgentSession, input: {
+        readonly cursor?: string;
+        readonly limit?: number;
+    }) => Promise<ConversationHistoryPage>);
+    projectInitial(session: NodeAgentSession, page: ConversationHistoryPage, limit: number): ConversationSegmentPage;
+    read(session: NodeAgentSession, input: {
+        readonly cursor?: string;
+        readonly limit?: number;
+    }): Promise<ConversationSegmentPage>;
+}