@myagentroam/node 0.9.135 → 0.9.137

package/dist/runner/codex-runner.js

@@ -5,7 +5,7 @@ import { homedir } from 'node:os';
 import { resolve } from 'node:path';
 import { discoverAllNativeSessions } from '../native-session-history.js';
 import { readCodexNativeContextUsage } from '../native-session-history.js';
-import { codexThreadCwd, deduplicateDirectSessions, extractCodexThreads, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
+import { codexThreadCwd, codexThreadHistoryModes, codexPaginatedThread, codexPaginatedCursor, codexPaginatedConversationPage, deduplicateDirectSessions, extractCodexThreads, isWithinWorkspace, latestNativeActivity } from './codex/conversation-parser.js';
 import { codexSessionControl } from '../codex-app-server.js';
 import { extractId } from '../util/runner-native-session-parsers.js';
 import { nodeLog } from '../operational.js';
@@ -19,6 +19,8 @@ export class CodexRunner extends AbstractRunner {
     discoveryScope = 'ALL_WORKSPACES';
     execution = new CodexExecutionState();
     fastEnabled = false;
+    threadHistoryModes = new Map();
+    threadHistoryModeReads = new Map();
     runClients = new Map();
     notificationListeners = new Set();
     clientNotificationDisposers = new Map();
@@ -265,9 +267,36 @@ export class CodexRunner extends AbstractRunner {
         return input.title;
     }
     async readConversationHistory(readers) {
-        // Codex JSONL is the only source for normal history reads.
-        const native = await readers.native();
-        return native === undefined ? undefined : { ...native, source: 'native' };
+        const page = await readers.official();
+        return page === undefined ? undefined : { ...page, source: 'official' };
+    }
+    async readOfficialConversation(session, input, managedTurn, registerImages) {
+        if (session.externalSessionId === null)
+            return undefined;
+        const threadId = session.externalSessionId;
+        const cursor = codexPaginatedCursor(session.id, input.cursor);
+        const limit = Math.min(Math.max(input.limit ?? 30, 1), 100);
+        await this.start();
+        await this.readThreadHistoryMode(threadId);
+        const page = await this.client.listThreadTurns(threadId, {
+            ...(cursor === undefined ? {} : { cursor }),
+            limit
+        });
+        const nextCursor = typeof page === 'object' && page !== null && 'nextCursor' in page
+            ? page.nextCursor
+            : undefined;
+        let earlierTurnId = null;
+        if (typeof nextCursor === 'string') {
+            const earlier = await this.client.listThreadTurns(threadId, { cursor: nextCursor, limit: 1 });
+            if (typeof earlier !== 'object' ||
+                earlier === null ||
+                !('data' in earlier) ||
+                !Array.isArray(earlier.data) ||
+                typeof earlier.data[0]?.id !== 'string')
+                throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+            earlierTurnId = earlier.data[0].id;
+        }
+        return codexPaginatedConversationPage(session, page, earlierTurnId, managedTurn, registerImages);
     }
     acceptsTruncatedNativeHistory() {
         return true;
@@ -340,7 +369,8 @@ export class CodexRunner extends AbstractRunner {
         let threads = [];
         try {
             await this.start();
-            threads = extractCodexThreads(await this.listThreads());
+            const result = await this.listThreads();
+            threads = extractCodexThreads(result);
         }
         catch {
             // Native transcripts remain a valid read-only discovery source.
@@ -427,7 +457,8 @@ export class CodexRunner extends AbstractRunner {
                     'session.rename',
                     'session.remove',
                     'session.pin',
-                    ...(session.externalSessionId === null ? [] : ['session.rewind'])
+                    ...(session.externalSessionId === null ? [] : ['session.rewind']),
+                    ...(this.supportsRollback(session) ? ['session.rollback'] : [])
                 ],
                 reasonCode: null
             }
@@ -498,6 +529,8 @@ export class CodexRunner extends AbstractRunner {
                 client.clearEnvironment();
             }
         this.runClients.clear();
+        this.threadHistoryModes.clear();
+        this.threadHistoryModeReads.clear();
         this.client.stop();
         if (this.profileCacheTimer !== undefined)
             clearTimeout(this.profileCacheTimer);
@@ -539,11 +572,52 @@ export class CodexRunner extends AbstractRunner {
     respond(requestId, result, runId) {
         this.clientFor(runId).respond(requestId, result);
     }
-    listThreads() {
-        return this.client.listThreads();
+    async listThreads() {
+        const result = await this.client.listThreads();
+        this.observeThreadHistoryModes(result);
+        return result;
+    }
+    observeThreadHistoryModes(result, expectedThreadId) {
+        for (const descriptor of codexThreadHistoryModes(result))
+            if (expectedThreadId === undefined || descriptor.id === expectedThreadId)
+                this.threadHistoryModes.set(descriptor.id, descriptor.paginated);
+    }
+    readThreadHistoryMode(threadId) {
+        if (this.threadHistoryModes.has(threadId))
+            return Promise.resolve();
+        const existing = this.threadHistoryModeReads.get(threadId);
+        if (existing !== undefined)
+            return existing;
+        const read = this.client
+            .readThread(threadId)
+            .then((result) => {
+            if (this.threadHistoryModeReads.get(threadId) !== read)
+                return;
+            if (!this.threadHistoryModes.has(threadId))
+                this.observeThreadHistoryModes(result, threadId);
+            if (!this.threadHistoryModes.has(threadId))
+                this.threadHistoryModes.set(threadId, false);
+        })
+            .catch(() => {
+            // A capability probe must not make otherwise readable history unavailable.
+            if (this.threadHistoryModeReads.get(threadId) === read &&
+                !this.threadHistoryModes.has(threadId))
+                this.threadHistoryModes.set(threadId, false);
+        })
+            .finally(() => {
+            if (this.threadHistoryModeReads.get(threadId) === read)
+                this.threadHistoryModeReads.delete(threadId);
+        });
+        this.threadHistoryModeReads.set(threadId, read);
+        return read;
     }
     startThread(cwd, configuration, runId) {
-        return this.clientFor(runId).startThread(cwd, configuration);
+        return this.clientFor(runId)
+            .startThread(cwd, configuration)
+            .then((result) => {
+            this.observeThreadHistoryModes(result);
+            return result;
+        });
     }
     forkThread(threadId, cwd, lastTurnId, configuration) {
         return this.client.forkThread(threadId, cwd, lastTurnId, configuration);
@@ -558,12 +632,41 @@ export class CodexRunner extends AbstractRunner {
                 ? await client.startThread(session.cwd, configuration)
                 : await client.forkThread(threadId, session.cwd, boundary, configuration);
             const forkedThreadId = extractId(result, 'thread');
+            this.observeThreadHistoryModes(result);
             await client.setThreadName(forkedThreadId, title);
             return forkedThreadId;
         });
     }
+    supportsRollback(session) {
+        return (session.externalSessionId !== null &&
+            this.threadHistoryModes.get(session.externalSessionId) === true);
+    }
+    async rollbackNative(session, boundary, targetTurnBoundary) {
+        void boundary;
+        if (!this.supportsRollback(session) || targetTurnBoundary === undefined)
+            throw new Error('SESSION_ROLLBACK_UNAVAILABLE');
+        const threadId = session.externalSessionId;
+        return this.withTemporaryClient(async (client) => {
+            const resumed = await client.resumeThread(threadId, session.cwd, {
+                model: session.model,
+                effort: session.effort,
+                access: session.access
+            });
+            if (!codexPaginatedThread(resumed)) {
+                this.threadHistoryModes.set(threadId, false);
+                throw new Error('SESSION_ROLLBACK_UNAVAILABLE');
+            }
+            await client.revertThread(threadId, targetTurnBoundary);
+            return Date.now();
+        });
+    }
     resumeThread(threadId, cwd, configuration, runId) {
-        return this.clientFor(runId).resumeThread(threadId, cwd, configuration);
+        return this.clientFor(runId)
+            .resumeThread(threadId, cwd, configuration)
+            .then((result) => {
+            this.observeThreadHistoryModes(result, threadId);
+            return result;
+        });
     }
     startTurn(threadId, text, cwd, configuration, attachments, runId) {
         return this.clientFor(runId).startTurn(threadId, text, cwd, configuration, attachments);

package/dist/runner/mar-agent/computer-use.js

@@ -199,6 +199,7 @@ export const computerUseToolDefinition = {
         additionalProperties: false
     },
     parallelSafety: 'serial',
+    allowedCallers: ['direct'],
     agentScope: 'ROOT_ONLY'
 };
 class ComputerUseRunSession {

package/dist/runner/mar-agent/conversation-normalizer.js

@@ -30,16 +30,18 @@ export class MarAgentConversationNormalizer {
         }
         if (event.type === 'message.completed') {
             const modelName = record(event)?.modelName;
+            const itemId = this.messageItemId(event.itemId);
+            const payload = {
+                text: event.text,
+                format: 'markdown',
+                model: typeof modelName === 'string' ? modelName : null
+            };
             return [
                 {
-                    itemId: this.messageItemId(event.itemId),
+                    itemId,
                     kind: 'assistant_message',
                     status: 'COMPLETED',
-                    payload: {
-                        text: event.text,
-                        format: 'markdown',
-                        model: typeof modelName === 'string' ? modelName : null
-                    }
+                    payload
                 }
             ];
         }
@@ -61,12 +63,17 @@ export class MarAgentConversationNormalizer {
                     payload: { sections: [{ index: 0, text: compactRunnerText(event.text, 10_000) }] }
                 }
             ];
-        if (event.type === 'tool.started')
-            return this.#toolStarted(event);
-        if (event.type === 'tool.completed')
-            return this.#toolCompleted(event);
-        if (event.type === 'tool.failed')
+        if (event.type === 'tool.started' ||
+            event.type === 'tool.completed' ||
+            event.type === 'tool.failed') {
+            if (event.parentCallId !== undefined)
+                return [];
+            if (event.type === 'tool.started')
+                return this.#toolStarted(event);
+            if (event.type === 'tool.completed')
+                return this.#toolCompleted(event);
             return this.#toolFailed(event);
+        }
         if (event.type === 'hosted_tool.updated') {
             const sourceSummary = event.summary.sources
                 ?.slice(0, 20)

package/dist/runner/mar-agent/hosted-conversation-runtime.js

@@ -228,6 +228,7 @@ export class MarAgentHostedConversationRuntime {
             : undefined;
         const mcp = 'mcpServers' in input && input.mcpServers.length > 0
             ? await MarAgentMcpClientPool.connect(input.mcpServers, input.workspaceDirectory, {
+                authorizationScope: JSON.stringify([input.homeDirectory, input.sessionId]),
                 processExecutor: input.processExecutor,
                 owner: {
                     sessionId: input.sessionId,
@@ -270,8 +271,8 @@ export class MarAgentHostedConversationRuntime {
                 ...(mcp === undefined
                     ? {}
                     : {
-                        mcpTools: mcp.definitions(),
-                        callMcp: (call) => mcp.call(call.name, call.arguments)
+                        mcpCatalog: () => mcp.catalog(),
+                        callMcp: (call, signal, context) => mcp.call(call.name, call.arguments, signal, context?.expectedTool)
                     }),
                 allowUntrustedTls: false
             });

package/dist/runner/mar-agent/managed-run-controller.js

@@ -163,7 +163,8 @@ export class MarAgentManagedRunController {
             const mcpSecretEnvironment = parseSecretEnvironment(payload.mcpSecretEnvironment);
             mcpServers = this.runner.mcpConfiguration(payload.mcpInstallations, {
                 ...secretEnvironment,
-                ...mcpSecretEnvironment
+                ...mcpSecretEnvironment,
+                MAR_USERNAME: secretEnvironment['MAR_USERNAME'] ?? ''
             });
             if (mcpServers.some((server) => server.name === 'computer'))
                 throw new Error('MAR_AGENT_MCP_RESERVED_NAMESPACE');
@@ -271,6 +272,7 @@ export class MarAgentManagedRunController {
             if (runtime.activeRunId !== undefined)
                 throw new Error('MAR_AGENT_SESSION_RUNTIME_ACTIVE');
             runtime.activeRunId = input.runId;
+            await runtime.mcpLease.pool.refreshForExecution();
             const executionMcpServers = input.mcpServers.filter((server) => server.lifecycle === 'EXECUTION');
             computerUseBinding = await this.#computerUse?.bind({
                 runId: input.runId,
@@ -290,7 +292,8 @@ export class MarAgentManagedRunController {
             }
             if (executionMcpServers.length > 0) {
                 executionMcpLease = await this.#mcpClients.acquire(executionMcpServers, input.cwd, {
-                    reusable: false
+                    reusable: false,
+                    authorizationScope: runtime.session.id
                 });
             }
             const userTools = executionMcpLease?.pool.definitions() ?? [];
@@ -311,11 +314,37 @@ export class MarAgentManagedRunController {
                 skills: [...(imageExtensions.skills ?? []), computerUseHostSkill]
             }, {
                 tools: [...nodeTools, ...userTools],
-                call: async (call, signal) => {
+                catalog: () => {
+                    const external = executionMcpLease?.pool.catalog() ?? {
+                        revision: '',
+                        servers: [],
+                        tools: []
+                    };
+                    const computer = nodeTools.map((definition) => ({
+                        definition,
+                        serverId: 'computer',
+                        rawName: definition.name,
+                        sourceIdentity: `node:${input.runId}:computer`,
+                        definitionRevision: createHash('sha256')
+                            .update(JSON.stringify(definition))
+                            .digest('hex'),
+                        lifetime: 'execution',
+                        exposure: 'direct'
+                    }));
+                    return {
+                        revision: `${external.revision}:${input.runId}`,
+                        servers: [
+                            ...external.servers,
+                            ...(computer.length ? [{ id: 'computer', name: 'Computer' }] : [])
+                        ],
+                        tools: [...external.tools, ...computer]
+                    };
+                },
+                call: async (call, signal, context) => {
                     if (computerUseBinding?.tools.some((tool) => tool.name === call.name))
                         return computerUseBinding.call(call, signal);
                     if (executionMcpLease?.pool.definitions().some((tool) => tool.name === call.name))
-                        return executionMcpLease.pool.call(call.name, call.arguments);
+                        return executionMcpLease.pool.call(call.name, call.arguments, signal, context?.expectedTool);
                     throw new Error('MAR_AGENT_MCP_TOOL_NOT_FOUND');
                 }
             });
@@ -472,7 +501,11 @@ export class MarAgentManagedRunController {
         const dynamicCredentials = input.models.some((model) => model.credential?.type === 'RUNTIME_TICKET' ||
             model.imageGeneration?.credential?.type === 'RUNTIME_TICKET');
         const sharedMcpServers = input.mcpServers.filter((server) => server.lifecycle !== 'EXECUTION');
-        const mcpLease = await this.#mcpClients.acquire(sharedMcpServers, input.cwd);
+        const mcpLease = await this.#mcpClients.acquire(sharedMcpServers, input.cwd, {
+            // Native Session IDs are assigned after the first lease; do not let that promotion
+            // change a confirmed actor's discovery identity when its warm runtime is recreated.
+            authorizationScope: input.secretEnvironment?.['MAR_USERNAME'] ? input.cwd : sessionKey
+        });
         let agent;
         let runtime;
         let models = [];
@@ -488,8 +521,8 @@ export class MarAgentManagedRunController {
                     const runId = runtime?.activeRunId;
                     return runId === undefined ? {} : this.requestQuestion(runId, request, signal);
                 },
-                mcpTools: mcp.definitions(),
-                callMcp: async (call) => mcp.call(call.name, call.arguments),
+                mcpCatalog: () => mcp.catalog(),
+                callMcp: async (call, signal, context) => mcp.call(call.name, call.arguments, signal, context?.expectedTool),
                 webSearch: (request, signal) => this.host.webSearch(request, signal),
                 allowUntrustedTls: allowsUntrustedWebFetchTls(hostConfiguration.environment),
                 resourceIdleTtlMs: this.#resourceIdleTtlMs
@@ -635,7 +668,12 @@ export class MarAgentManagedRunController {
     project(runId, event) {
         if (contextUsageChanged(event))
             this.host.refreshContext?.(runId);
-        if (event.type === 'message.delta')
+        if (event.type === 'model.performance')
+            this.host.emit(runId, 'run.performance', {
+                latencyMs: event.latencyMs,
+                ...(event.tokensPerSecond === undefined ? {} : { tokensPerSecond: event.tokensPerSecond })
+            });
+        else if (event.type === 'message.delta')
             this.host.emit(runId, 'text.delta', {
                 text: event.delta,
                 phase: event.phase,