@myagentroam/node 0.1.8 → 0.9.2

package/dist/runner/opencode-runner.d.ts

@@ -30,6 +30,7 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
     protected profileForValidation(): RunnerProfile;
     supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: NodeWorkspace): boolean;
     defaultConfiguration(workspace?: NodeWorkspace): RunnerDefaultConfiguration;
+    mcpConfiguration(raw: unknown, secrets: Readonly<Record<string, string>>): unknown;
     discoverSessions(context: RunnerDiscoveryContext, workspace?: NodeWorkspace): Promise<readonly NodeAgentSession[]>;
     resumeExternal(external: NodeAgentSession, context: ExternalResumeContext): Promise<ExternalResumeResult>;
     readExternalActivity(session: NodeAgentSession): Promise<"UNAVAILABLE" | "EXTERNAL_ACTIVE" | "IDLE">;
@@ -55,6 +56,6 @@ export declare class OpenCodeRunner extends AbstractRunner<'opencode'> {
         maxTokens: number;
     } | undefined>;
     stop(): Promise<void>;
-    managedClient(environment: Readonly<Record<string, string>>): OpenCodeServerClient;
+    managedClient(environment: Readonly<Record<string, string>>, isolationKey?: string): OpenCodeServerClient;
     releaseManagedClient(client: OpenCodeServerClient): void;
 }

package/dist/runner/opencode-runner.js

@@ -87,6 +87,24 @@ export class OpenCodeRunner extends AbstractRunner {
             access: 'default'
         };
     }
+    mcpConfiguration(raw, secrets) {
+        const servers = super.mcpConfiguration(raw, secrets);
+        return Object.fromEntries(servers.map((server) => [
+            server.name,
+            server.transport === 'STDIO'
+                ? {
+                    type: 'local',
+                    command: [server.command, ...(server.args ?? [])],
+                    environment: { ...(server.environment ?? {}) }
+                }
+                : {
+                    type: 'remote',
+                    url: server.url,
+                    headers: { ...(server.headers ?? {}) },
+                    oauth: false
+                }
+        ]));
+    }
     async discoverSessions(context, workspace) {
         const result = [];
         for (const target of workspace === undefined ? context.workspaces : [workspace]) {
@@ -270,11 +288,13 @@ export class OpenCodeRunner extends AbstractRunner {
         await Promise.allSettled(stopping);
         this.stoppingClients.clear();
     }
-    managedClient(environment) {
+    managedClient(environment, isolationKey) {
         const entries = Object.entries(environment).sort(([left], [right]) => left.localeCompare(right));
-        if (entries.length === 0)
+        if (entries.length === 0 && isolationKey === undefined)
             return this.client;
-        const fingerprint = createHash('sha256').update(JSON.stringify(entries)).digest('hex');
+        const fingerprint = createHash('sha256')
+            .update(JSON.stringify({ entries, isolationKey }))
+            .digest('hex');
         const existing = this.environmentClients.get(fingerprint);
         if (existing !== undefined) {
             existing.leases += 1;

package/dist/runner/runner-registry.d.ts

@@ -10,7 +10,7 @@ export declare class RunnerRegistry {
     product(name: unknown): AbstractRunner<RunnerName> | undefined;
     profiles(capabilities: NodeCapabilities): readonly RunnerProfile[];
     refreshProfiles(capabilities: NodeCapabilities, workspace?: import('../database.js').NodeWorkspace, environment?: Readonly<Record<string, string>>): Promise<readonly RunnerProfile[]>;
-    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: import('../database.js').NodeWorkspace): boolean;
+    supportsConfiguration(configuration: RunnerDefaultConfiguration, workspace?: import('../database.js').NodeWorkspace, environment?: Readonly<Record<string, string>>): boolean;
     startManagedRun(envelope: NodeEnvelope): boolean;
     cancelManagedRun(runId: string, intent: RunnerCancellationIntent): boolean;
     decideApproval(input: RunnerApprovalDecision): boolean;

package/dist/runner/runner-registry.js

@@ -38,8 +38,8 @@ export class RunnerRegistry {
         const profiles = await Promise.all(this.advertised().map((runner) => runner.refreshProfile(capabilities, workspace, environment)));
         return profiles.flatMap((profile) => (profile === undefined ? [] : [profile]));
     }
-    supportsConfiguration(configuration, workspace) {
-        return (this.product(configuration.runner)?.supportsConfiguration(configuration, workspace) === true);
+    supportsConfiguration(configuration, workspace, environment) {
+        return (this.product(configuration.runner)?.supportsConfiguration(configuration, workspace, environment) === true);
     }
     startManagedRun(envelope) {
         const runnerName = envelope.payload.runner;

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,57 +1,41 @@
-// Codex reasoning efforts follow the official Codex model surface. Keep this
-// shared so an alias such as GPT-5.6 Luna cannot accidentally lose `high`.
-const CODEX_REASONING_EFFORTS = ['low', 'medium', 'high', 'xhigh'];
 const CLAUDE_MODEL_ENVIRONMENT = {
     opus: 'ANTHROPIC_DEFAULT_OPUS_MODEL',
     sonnet: 'ANTHROPIC_DEFAULT_SONNET_MODEL',
     haiku: 'ANTHROPIC_DEFAULT_HAIKU_MODEL'
 };
 /**
- * The Runner APIs used by MAR do not expose a portable model-list endpoint.
- * Keep the supported, product-visible choices in one Node-owned definition so
- * the browser never guesses models, effort levels, permission modes, or slash
- * commands. Model aliases for Claude are accepted by the Agent SDK and avoid
- * coupling the UI to a vendor version suffix.
+ * Keep product-visible permission modes and slash commands in one Node-owned
+ * definition. Codex models are supplied by App Server `model/list`; Claude
+ * aliases are accepted by the Agent SDK and avoid coupling the UI to a vendor
+ * version suffix.
  */
 const definitions = {
     codex: {
         runner: 'codex',
-        models: [
-            {
-                id: 'gpt-5.6-sol',
-                label: 'GPT-5.6 Sol',
-                supportedEfforts: [...CODEX_REASONING_EFFORTS]
-            },
+        models: [],
+        accessOptions: [
             {
-                id: 'gpt-5.6-terra',
-                label: 'GPT-5.6 Terra',
-                supportedEfforts: [...CODEX_REASONING_EFFORTS]
+                id: 'on-request',
+                label: 'On-request',
+                description: 'Ask when additional permission is required.'
             },
-            {
-                id: 'gpt-5.6-luna',
-                label: 'GPT-5.6 Luna',
-                supportedEfforts: [...CODEX_REASONING_EFFORTS]
-            }
-        ],
-        accessOptions: [
-            { id: 'on-request', label: 'On-request', description: '由 Codex 在需要额外权限时请求确认。' },
             {
                 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: 'Compact the current session context.',
                 inputHint: '/compact',
                 interaction: 'IMMEDIATE_ACTION'
             },
@@ -59,14 +43,14 @@ const definitions = {
                 id: 'plan',
                 label: '/plan',
                 stateLabel: 'Plan Mode',
-                description: '开启或关闭协作规划模式。',
+                description: 'Toggle collaborative Plan Mode.',
                 inputHint: '/plan',
                 interaction: 'TOGGLE'
             },
             {
                 id: 'fast',
                 label: '/fast',
-                description: '开启或关闭当前模型可用的快速服务层。',
+                description: 'Toggle the fast service tier when supported.',
                 inputHint: '/fast',
                 interaction: 'TOGGLE'
             }
@@ -94,21 +78,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: 'Compact context through the Claude Agent SDK.',
                 inputHint: '/compact',
                 source: 'CLAUDE_AGENT_SDK',
                 interaction: 'IMMEDIATE_ACTION',
@@ -120,7 +108,7 @@ const definitions = {
                 runner: 'claude-code',
                 label: '/plan',
                 stateLabel: 'Plan Mode',
-                description: '开启或关闭标签式规划模式，只读规划并输出计划卡。',
+                description: 'Toggle read-only tagged Plan Mode.',
                 inputHint: '/plan',
                 source: 'CLAUDE_AGENT_SDK',
                 interaction: 'TOGGLE',
@@ -136,12 +124,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: [
@@ -149,7 +137,7 @@ const definitions = {
                 id: 'compact',
                 runner: 'opencode',
                 label: '/compact',
-                description: '通过 OpenCode 压缩当前会话上下文。',
+                description: 'Compact context through OpenCode.',
                 inputHint: '/compact',
                 source: 'OPENCODE_SERVER',
                 interaction: 'IMMEDIATE_ACTION',
@@ -161,7 +149,7 @@ const definitions = {
                 runner: 'opencode',
                 label: '/plan',
                 stateLabel: 'Plan Mode',
-                description: '开启或关闭 OpenCode 原生 Plan Agent。',
+                description: 'Toggle the native OpenCode Plan Agent.',
                 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-command-detector.d.ts

@@ -0,0 +1,3 @@
+import type { RuntimeCommand } from '@myagentroam/protocol';
+export declare function detectRuntimeCommands(): Promise<RuntimeCommand[]>;
+export declare function normalizeVersion(id: RuntimeCommand['id'], value: string): string | undefined;

package/dist/runtime-command-detector.js

@@ -0,0 +1,78 @@
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+const execFileAsync = promisify(execFile);
+const COMMANDS = [
+    { id: 'npx', candidates: ['npx'], versionArguments: ['--version'] },
+    { id: 'git', candidates: ['git'], versionArguments: ['--version'] },
+    { id: 'python', candidates: ['python3', 'python'], versionArguments: ['--version'] },
+    { id: 'pip', candidates: ['pip3', 'pip'], versionArguments: ['--version'] }
+];
+export async function detectRuntimeCommands() {
+    return Promise.all(COMMANDS.map(detectCommand));
+}
+async function detectCommand(descriptor) {
+    for (const command of descriptor.candidates) {
+        try {
+            const [{ stdout, stderr }, path] = await Promise.all([
+                executeVersion(command, descriptor.versionArguments),
+                resolveCommandPath(command)
+            ]);
+            const version = normalizeVersion(descriptor.id, `${stdout}${stderr}`.trim().split(/\r?\n/u)[0]?.trim() ?? '');
+            return {
+                id: descriptor.id,
+                command,
+                available: true,
+                ...(version === undefined || version === '' ? {} : { version }),
+                ...(path === undefined ? {} : { path })
+            };
+        }
+        catch {
+            // Try the platform-compatible fallback command name.
+        }
+    }
+    return {
+        id: descriptor.id,
+        command: descriptor.candidates[0],
+        available: false
+    };
+}
+export function normalizeVersion(id, value) {
+    const normalized = value.trim();
+    if (normalized === '')
+        return undefined;
+    const patterns = {
+        git: /^git version\s+(\S+)/iu,
+        python: /^python\s+(\S+)/iu,
+        pip: /^pip\s+(\S+)/iu
+    };
+    const match = patterns[id]?.exec(normalized);
+    return (match?.[1] ?? normalized).slice(0, 512);
+}
+async function executeVersion(command, args) {
+    const executable = process.platform === 'win32' ? process.env['ComSpec'] || 'cmd.exe' : command;
+    const commandArgs = process.platform === 'win32'
+        ? ['/d', '/s', '/c', [command, ...args].map(quoteWindowsArgument).join(' ')]
+        : [...args];
+    return execFileAsync(executable, commandArgs, {
+        timeout: 5_000,
+        maxBuffer: 64 * 1024,
+        windowsHide: true
+    });
+}
+function quoteWindowsArgument(value) {
+    return `"${value.replaceAll('"', '""')}"`;
+}
+async function resolveCommandPath(command) {
+    try {
+        const resolver = process.platform === 'win32' ? 'where.exe' : 'which';
+        const { stdout } = await execFileAsync(resolver, [command], {
+            timeout: 2_000,
+            maxBuffer: 64 * 1024,
+            windowsHide: true
+        });
+        return stdout.trim().split(/\r?\n/u)[0]?.trim().slice(0, 2048) || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

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>;
+}

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

@@ -0,0 +1,155 @@
+const TURN_PAGE_SIZE = 30;
+export function conversationSegments(turn) {
+    const groups = [];
+    let current = [];
+    for (const item of turn.items) {
+        current.push(item);
+        if (item.kind !== 'assistant_message')
+            continue;
+        groups.push(current);
+        current = [];
+    }
+    if (current.length > 0 || groups.length === 0)
+        groups.push(current);
+    return groups.map((items, index) => {
+        const id = `${turn.id}:segment:${index}`;
+        const latest = index === groups.length - 1;
+        const projectedItems = items.map((item) => ({
+            ...item,
+            segmentId: id,
+            segmentIndex: index
+        }));
+        return {
+            id,
+            sessionId: turn.sessionId,
+            turnId: turn.id,
+            runId: turn.runId,
+            index,
+            status: (latest ? turn.status : 'SUCCEEDED'),
+            ...(latest && turn.rewind !== undefined ? { rewind: turn.rewind } : {}),
+            items: projectedItems,
+            startedAt: projectedItems[0]?.startedAt ?? turn.startedAt,
+            completedAt: projectedItems.at(-1)?.completedAt ?? null
+        };
+    });
+}
+export function conversationSegmentIdentityForItem(turn, itemId, itemKind) {
+    let index = 0;
+    const runtimeItemId = turn.runId === null ? itemId : `${turn.runId}:${itemId}`;
+    for (const item of turn.items) {
+        if (item.id === itemId || item.id === runtimeItemId)
+            return { id: `${turn.id}:segment:${index}`, index };
+        if (item.kind === 'assistant_message')
+            index += 1;
+    }
+    if (itemKind === 'assistant_message' && turn.items.at(-1)?.kind === 'assistant_message')
+        index -= 1;
+    return { id: `${turn.id}:segment:${index}`, index };
+}
+export class ConversationSegmentService {
+    readTurns;
+    constructor(readTurns) {
+        this.readTurns = readTurns;
+    }
+    projectInitial(session, page, limit) {
+        const all = page.turns.flatMap(conversationSegments);
+        const segments = all.slice(-limit);
+        return {
+            snapshotSequence: page.snapshotSequence,
+            source: page.source,
+            readAt: page.readAt,
+            latestVisibleAt: page.latestVisibleAt,
+            unit: 'SEGMENT',
+            segments,
+            nextCursor: segments.length === 0 || (segments.length === all.length && page.nextCursor === null)
+                ? null
+                : encodeCursor({
+                    version: 1,
+                    sessionId: session.id,
+                    beforeSegmentId: segments[0].id
+                })
+        };
+    }
+    async read(session, input) {
+        const limit = Math.min(Math.max(input.limit ?? 30, 1), 500);
+        const boundary = input.cursor === undefined ? undefined : decodeCursor(input.cursor, session.id);
+        const collected = [];
+        const visited = new Set();
+        let turnCursor;
+        let locatingBoundary = boundary !== undefined;
+        let hasOlder = false;
+        let metadata;
+        while (collected.length < limit) {
+            const page = await this.readTurns(session, {
+                ...(turnCursor === undefined ? {} : { cursor: turnCursor }),
+                limit: TURN_PAGE_SIZE
+            });
+            metadata ??= {
+                snapshotSequence: page.snapshotSequence,
+                source: page.source,
+                readAt: page.readAt,
+                latestVisibleAt: page.latestVisibleAt
+            };
+            const pageSegments = page.turns.flatMap(conversationSegments);
+            let eligible = pageSegments;
+            if (locatingBoundary) {
+                const boundaryIndex = pageSegments.findIndex((segment) => segment.id === boundary?.beforeSegmentId);
+                if (boundaryIndex >= 0) {
+                    eligible = pageSegments.slice(0, boundaryIndex);
+                    locatingBoundary = false;
+                }
+                else
+                    eligible = [];
+            }
+            if (!locatingBoundary && eligible.length > 0) {
+                const remaining = Math.max(0, limit - collected.length);
+                const take = eligible.slice(-remaining);
+                hasOlder = eligible.length > take.length || page.nextCursor !== null;
+                collected.unshift(...take);
+            }
+            if (collected.length >= limit || page.nextCursor === null)
+                break;
+            if (visited.has(page.nextCursor))
+                throw new Error('EVENT_CURSOR_INVALID');
+            visited.add(page.nextCursor);
+            turnCursor = page.nextCursor;
+        }
+        if (locatingBoundary)
+            throw new Error('EVENT_CURSOR_INVALID');
+        const nextCursor = collected.length === 0 || !hasOlder
+            ? null
+            : encodeCursor({
+                version: 1,
+                sessionId: session.id,
+                beforeSegmentId: collected[0].id
+            });
+        return {
+            ...(metadata ?? {
+                snapshotSequence: 0,
+                source: 'runtime',
+                readAt: Date.now(),
+                latestVisibleAt: 0
+            }),
+            unit: 'SEGMENT',
+            segments: collected,
+            nextCursor
+        };
+    }
+}
+function encodeCursor(cursor) {
+    return Buffer.from(JSON.stringify(cursor)).toString('base64url');
+}
+function decodeCursor(value, sessionId) {
+    try {
+        const decoded = JSON.parse(Buffer.from(value, 'base64url').toString('utf8'));
+        if (decoded.version !== 1 ||
+            decoded.sessionId !== sessionId ||
+            typeof decoded.beforeSegmentId !== 'string' ||
+            decoded.beforeSegmentId.length === 0)
+            throw new Error('EVENT_CURSOR_INVALID');
+        return decoded;
+    }
+    catch {
+        throw new Error('EVENT_CURSOR_INVALID');
+    }
+}

package/dist/service/mcp-installation-verifier.d.ts

@@ -0,0 +1,9 @@
+import type { McpCatalogEntry, McpInstallationConfiguration } from '@myagentroam/protocol';
+export declare class McpInstallationVerifier {
+    verify(input: {
+        readonly entry: McpCatalogEntry;
+        readonly configuration: McpInstallationConfiguration;
+        readonly secrets: Readonly<Record<string, string>>;
+        readonly cwd: string;
+    }): Promise<void>;
+}