@myagentroam/node 0.9.134 → 0.9.136

package/dist/capabilities.js

@@ -9,6 +9,7 @@ const runtimeCredentialCapability = () => ({
     apiVersion: 1,
     websocket: true,
     fastMode: true,
+    serviceTiers: ['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast'],
     namespacedTools: true,
     httpVersions: ['1.1', '2']
 });

package/dist/codex-app-server.js

@@ -237,6 +237,9 @@ export class CodexAppServerClient {
     listThreads() {
         return this.request('thread/list', {});
     }
+    readThread(threadId) {
+        return this.request('thread/read', { threadId, includeTurns: false });
+    }
     listCollaborationModes() {
         return this.request('collaborationMode/list', {});
     }
@@ -251,6 +254,17 @@ export class CodexAppServerClient {
             ...codexThreadConfiguration(cwd, configuration)
         });
     }
+    revertThread(threadId, beforeTurnId) {
+        return this.request('thread/revert', { threadId, beforeTurnId });
+    }
+    listThreadTurns(threadId, input) {
+        return this.request('thread/turns/list', {
+            threadId,
+            ...input,
+            itemsView: 'full',
+            sortDirection: 'desc'
+        });
+    }
     setThreadName(threadId, name) {
         return this.request('thread/name/set', { threadId, name });
     }

package/dist/connector.js

@@ -1075,12 +1075,14 @@ export class NodeConnector {
                 const session = this.runtime.getAgentSession(sessionId);
                 return session?.channelToken ?? undefined;
             },
-            goalMessage: (session, content) => {
+            goalMessage: (session, content, intent) => {
                 const state = this.commandStates.get(session.id, 'goal');
                 if (state?.active !== true)
                     return undefined;
                 const current = this.goalRuntime.get(session.id);
                 if (current?.status === 'active') {
+                    if (intent !== 'REPLACE_CURRENT')
+                        return undefined;
                     this.invalidateGoalContinuation(session.id);
                     const resumed = this.goalRuntime.resume(session.id);
                     if (resumed !== current)
@@ -1111,7 +1113,7 @@ export class NodeConnector {
             prepareGoalInsertion: (sessionId, submissionId, goal) => {
                 if (!this.goalGenerationCurrent(sessionId, goal))
                     return false;
-                this.continuousRunCoordinator.removePendingQueue(sessionId, submissionId);
+                this.continuousRunCoordinator.removeGoalQueue(sessionId, undefined, submissionId);
                 return true;
             },
             goalPreparationFailed: (session, goal, activated) => this.handleGoalPreparationFailed(session, goal, activated)

package/dist/node-execution-environment.js

@@ -6,6 +6,14 @@ export function nodeExecutionEnvironment(provided = {}, inherited = process.env,
     const environment = Object.fromEntries(Object.entries(inherited).filter((entry) => typeof entry[1] === 'string'));
     Object.assign(environment, provided);
     environment['MAR_NODE_CONTEXT'] = '1';
+    // Never identify a new execution as the user that launched the Node service.
+    const username = provided['MAR_USERNAME'] ?? '';
+    if (username.length > 128 || /[\r\n\0]/u.test(username))
+        throw new Error('SECRET_ENVIRONMENT_INVALID');
+    for (const key of Object.keys(environment))
+        if (key.toUpperCase() === 'MAR_USERNAME')
+            delete environment[key];
+    environment['MAR_USERNAME'] = username;
     const platform = options.platform ?? process.platform;
     const packageRoot = options.packageRoot ?? resolve(dirname(fileURLToPath(import.meta.url)), '..');
     const cliBins = [join(packageRoot, 'node_modules', '.bin')];

package/dist/runner/abstract-runner.js

@@ -1,3 +1,4 @@
+import { createHash } from 'node:crypto';
 import { mcpRuntimeDescriptorSchema } from '@myagentroam/protocol';
 import { nodeExecutionEnvironment } from '../node-execution-environment.js';
 /**
@@ -78,8 +79,12 @@ export class AbstractRunner {
         void [session, boundary, title];
         throw new RunnerCapabilityError(this.name, 'session.rewind');
     }
-    async rollbackNative(session, boundary) {
-        void [session, boundary];
+    supportsRollback(session) {
+        void session;
+        return false;
+    }
+    async rollbackNative(session, boundary, targetTurnBoundary) {
+        void [session, boundary, targetTurnBoundary];
         throw new RunnerCapabilityError(this.name, 'session.rollback');
     }
     async clearNative(session) {
@@ -108,8 +113,8 @@ export class AbstractRunner {
         void [session, nativeSessionId];
         return undefined;
     }
-    async readOfficialConversation(session, input, managedTurn) {
-        void [session, input, managedTurn];
+    async readOfficialConversation(session, input, managedTurn, registerImages) {
+        void [session, input, managedTurn, registerImages];
         return undefined;
     }
     async readConversationHistory(readers) {
@@ -168,6 +173,7 @@ function resolvedMcpServers(raw, secrets) {
     if (!Array.isArray(raw))
         return [];
     const marmgrEnvironment = {
+        MAR_USERNAME: secrets['MAR_USERNAME'] ?? '',
         ...(secrets['MAR_MGR_SERVER_URL'] === undefined
             ? {}
             : { MAR_MGR_SERVER_URL: secrets['MAR_MGR_SERVER_URL'] }),
@@ -196,6 +202,16 @@ function resolvedMcpServers(raw, secrets) {
             result.push({
                 name: record['serverName'],
                 lifecycle: 'EXECUTION',
+                origin: 'BUILTIN',
+                allowedToolCallers: record['__marGoal'] === true
+                    ? { mar_get_goal: ['direct', 'programmatic'], mar_update_goal: ['direct'] }
+                    : record['__marScheduled'] === true
+                        ? {
+                            mar_get_scheduled_task: ['direct', 'programmatic'],
+                            mar_create_scheduled_task: ['direct'],
+                            mar_update_scheduled_task: ['direct']
+                        }
+                        : { mar_send_email_notification: ['direct'] },
                 transport: 'STDIO',
                 command: record['command'],
                 args: record['args'],
@@ -221,6 +237,15 @@ function resolvedMcpServers(raw, secrets) {
         if (!runtime.success)
             continue;
         const configuration = isRecord(record['configuration']) ? record['configuration'] : {};
+        const sourceIdentity = createHash('sha256')
+            .update(JSON.stringify({
+            id: record['id'] ?? null,
+            name: record['serverName'],
+            runtime: runtime.data,
+            configuration
+        }))
+            .digest('hex');
+        const authorizationIdentity = secrets['MAR_USERNAME']?.trim() || undefined;
         const resolveReferences = (candidate) => {
             if (!isRecord(candidate))
                 return {};
@@ -242,6 +267,9 @@ function resolvedMcpServers(raw, secrets) {
                 continue;
             result.push({
                 name: record['serverName'],
+                origin: 'USER',
+                sourceIdentity,
+                ...(authorizationIdentity === undefined ? {} : { authorizationIdentity }),
                 transport: 'STDIO',
                 command: runtime.data.command,
                 args: [
@@ -263,6 +291,9 @@ function resolvedMcpServers(raw, secrets) {
                 continue;
             result.push({
                 name: record['serverName'],
+                origin: 'USER',
+                sourceIdentity,
+                ...(authorizationIdentity === undefined ? {} : { authorizationIdentity }),
                 transport: 'HTTP',
                 url: runtime.data.url,
                 headers: {

package/dist/runner/claude/managed-run-controller.js

@@ -180,7 +180,8 @@ export class ClaudeManagedRunController {
                     : {}),
                 mcpServers: this.runner.mcpConfiguration(payload.mcpInstallations, {
                     ...secretEnvironment,
-                    ...mcpSecretEnvironment
+                    ...mcpSecretEnvironment,
+                    MAR_USERNAME: secretEnvironment['MAR_USERNAME'] ?? ''
                 }),
                 ...(attachments.length === 0
                     ? {}
@@ -331,6 +332,12 @@ export class ClaudeManagedRunController {
                         }
                     }
                     if (record.type === 'result') {
+                        const nativeTtft = [record.ttft_ms, record.ttft_stream_ms].find((value) => typeof value === 'number' &&
+                            Number.isFinite(value) &&
+                            value >= 0 &&
+                            Number.isSafeInteger(Math.round(value)));
+                        if (nativeTtft !== undefined)
+                            this.host.emit(runId, 'run.performance', { ttftMs: Math.round(nativeTtft) });
                         const subtype = typeof record.subtype === 'string' ? record.subtype : 'unknown';
                         const completedNativeSessionId = this.runner.execution.runs.get(runId)?.nativeSessionId ?? nativeSessionId;
                         this.host.emit(runId, 'turn.completed', {

package/dist/runner/codex/conversation-parser.js

@@ -1,3 +1,6 @@
+import { basename, extname } from 'node:path';
+import { runnerErrorProjection } from '../../util/runner-error.js';
+import { conversationImageAttachmentSchema } from '@myagentroam/protocol';
 import { parseCodexComposerImageMarkers } from './composer-image-markers.js';
 import { normalizeCodexTool } from './tool-normalizer.js';
 import { stripGoalStartPrompt } from '../../service/goal-runtime.js';
@@ -5,6 +8,68 @@ const MAX_COMPOSER_ATTACHMENT_BYTES = 5 * 1024 * 1024;
 const MAX_COMPOSER_ATTACHMENTS_BYTES = 10 * 1024 * 1024;
 const MAX_ASSISTANT_MESSAGE_CHARACTERS = 64 * 1024;
 export * from '../../util/runner-native-session-parsers.js';
+/** Only the official thread descriptor can declare history-only Revert support. */
+export function codexThreadHistoryModes(result) {
+    if (!isPlainRecord(result))
+        return [];
+    const descriptors = Array.isArray(result.data) ? result.data : [result.thread];
+    return descriptors.flatMap((value) => isPlainRecord(value) && typeof value.id === 'string'
+        ? [{ id: value.id, paginated: value.historyMode === 'paginated' }]
+        : []);
+}
+export function codexPaginatedThread(result) {
+    return (isPlainRecord(result) &&
+        isPlainRecord(result.thread) &&
+        result.thread.historyMode === 'paginated');
+}
+export function codexPaginatedCursor(sessionId, cursor) {
+    if (cursor === undefined)
+        return undefined;
+    try {
+        const value = JSON.parse(Buffer.from(cursor, 'base64url').toString('utf8'));
+        if (isPlainRecord(value) &&
+            value.source === 'codex-paginated' &&
+            value.sessionId === sessionId &&
+            typeof value.cursor === 'string' &&
+            value.cursor.length > 0)
+            return value.cursor;
+    }
+    catch {
+        // Invalid or foreign cursors never fall back to JSONL.
+    }
+    throw new Error('EVENT_CURSOR_INVALID');
+}
+export function codexPaginatedConversationPage(session, result, earlierTurnId, managedTurn, registerImages) {
+    if (!isPlainRecord(result) || !Array.isArray(result.data))
+        throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+    const values = result.data;
+    if (values.some((value) => !isPlainRecord(value) ||
+        typeof value.id !== 'string' ||
+        !Array.isArray(value.items) ||
+        value.itemsView !== 'full') ||
+        (result.nextCursor !== undefined &&
+            result.nextCursor !== null &&
+            typeof result.nextCursor !== 'string'))
+        throw new Error('NATIVE_TRANSCRIPT_UNAVAILABLE');
+    const turns = values.flatMap((value, index) => {
+        const native = value;
+        const turn = codexOfficialTurn(session, native, index, managedTurn(native.id), registerImages);
+        if (turn === undefined)
+            return [];
+        const earlier = values[index + 1];
+        return [{ ...turn, rewind: { before: earlier?.id ?? earlierTurnId, after: native.id } }];
+    });
+    return {
+        turns: turns.reverse(),
+        nextCursor: typeof result.nextCursor === 'string'
+            ? Buffer.from(JSON.stringify({
+                source: 'codex-paginated',
+                sessionId: session.id,
+                cursor: result.nextCursor
+            })).toString('base64url')
+            : null
+    };
+}
 export function codexOfficialConversationPage(session, result, input, managedTurnForNative) {
     if (!isPlainRecord(result) || !isPlainRecord(result.thread))
         return undefined;
@@ -34,12 +99,36 @@ export function codexOfficialConversationPage(session, result, input, managedTur
             : null
     };
 }
-export function codexOfficialTurn(session, value, sequence, managedTurn) {
+export function codexOfficialTurn(session, value, sequence, managedTurn, registerImages) {
     if (!isPlainRecord(value) || typeof value.id !== 'string' || !Array.isArray(value.items))
         return undefined;
+    const status = value.status === 'inProgress'
+        ? 'RUNNING'
+        : value.status === 'failed'
+            ? 'FAILED'
+            : value.status === 'interrupted'
+                ? 'INTERRUPTED'
+                : 'SUCCEEDED';
     const startedAt = codexTimestamp(value.startedAt);
     const completedAt = codexTimestamp(value.completedAt) ?? startedAt;
-    const items = codexOfficialItems(session, value.id, value.items, sequence, startedAt, completedAt);
+    const items = codexOfficialItems(session, value.id, value.items, sequence, startedAt, completedAt, registerImages);
+    if ((status === 'FAILED' || status === 'INTERRUPTED') && isPlainRecord(value.error)) {
+        const projected = runnerErrorProjection(value.error, 'CODEX_RUN_FAILED');
+        items.push({
+            id: `${session.id}:official:${value.id}:error`,
+            sessionId: session.id,
+            turnId: `${session.id}:official:${value.id}`,
+            runId: null,
+            parentItemId: null,
+            sourceSequence: sequence * 10_000 + value.items.length + 1,
+            revision: 0,
+            kind: 'error',
+            status: 'FAILED',
+            startedAt,
+            completedAt,
+            payload: { ...projected, recoverable: true, retryAfterMs: null }
+        });
+    }
     if (items.length === 0)
         return undefined;
     if (managedTurn !== undefined) {
@@ -98,6 +187,12 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
             let replacement;
             if (managedItem.kind === 'user_message')
                 replacement = officialUser;
+            else if (managedItem.kind === 'error' && isPlainRecord(managedItem.payload))
+                replacement = officialItems.find((item) => item.kind === 'error' &&
+                    isPlainRecord(item.payload) &&
+                    isPlainRecord(managedItem.payload) &&
+                    item.payload.code === managedItem.payload.code &&
+                    item.payload.message === managedItem.payload.message);
             else if (managedItem.kind === 'context_compaction')
                 replacement = officialContextCompactions.find((item) => !consumedOfficialIds.has(item.id));
             else {
@@ -123,7 +218,7 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
                 reconciledItems.push(item);
         return {
             ...managedTurn,
-            status: officialComplete ? 'SUCCEEDED' : managedTurn.status,
+            status: officialComplete ? status : managedTurn.status,
             // Reconcile against the managed runtime order. Official items replace
             // matching live projections in place; newly visible terminal items such
             // as a plan are appended after the commentary and tools that preceded it.
@@ -137,13 +232,13 @@ export function codexOfficialTurn(session, value, sequence, managedTurn) {
         sessionId: session.id,
         runId: null,
         userItemId: items.find((item) => item.kind === 'user_message')?.id ?? null,
-        status: 'SUCCEEDED',
+        status,
         model: null,
         effort: null,
         access: null,
         items,
         startedAt,
-        completedAt
+        completedAt: status === 'RUNNING' ? null : completedAt
     };
 }
 /**
@@ -197,15 +292,21 @@ export function conversationItemNativeId(itemId) {
     return markerIndex < 0 ? undefined : itemId.slice(markerIndex + marker.length);
 }
 /** Keep a custom tool invocation and its output in one Workbench card. */
-export function codexOfficialItems(session, nativeTurnId, values, turnSequence, startedAt, completedAt) {
+export function codexOfficialItems(session, nativeTurnId, values, turnSequence, startedAt, completedAt, registerImages) {
     const items = [];
     const pairedToolIndexes = new Map();
     // App Server preserves execution order within a Turn. Keep that order while
     // merging a paired tool invocation with its output into one Workbench card.
     for (const [itemSequence, value] of values.entries()) {
-        const item = codexOfficialItem(session, nativeTurnId, value, turnSequence, itemSequence, startedAt, completedAt);
+        let item = codexOfficialItem(session, nativeTurnId, value, turnSequence, itemSequence, startedAt, completedAt);
         if (item === undefined)
             continue;
+        if (isPlainRecord(value)) {
+            const sources = codexOfficialImageSources(value, item.id);
+            const attachments = sources.map((source) => registerImages?.([source])[0] ?? { name: source.name, mime: source.mime });
+            if (attachments.length > 0 && isPlainRecord(item.payload))
+                item = { ...item, payload: { ...item.payload, attachments } };
+        }
         // Codex persists one compaction as both `compacted` state and a
         // `context_compacted` event. App Server normalizes both records to
         // consecutive `contextCompaction` items without preserving their source.
@@ -229,7 +330,73 @@ export function codexOfficialItems(session, nativeTurnId, values, turnSequence,
         const result = invocation === item ? previous : item;
         items[existingIndex] = mergeCodexCustomToolItems(invocation, result);
     }
-    return items;
+    return [...coalesceImageGenerationItems(items)];
+}
+function codexLocalImageSource(path, name = basename(path)) {
+    const mime = {
+        '.png': 'image/png',
+        '.jpg': 'image/jpeg',
+        '.jpeg': 'image/jpeg',
+        '.gif': 'image/gif',
+        '.webp': 'image/webp'
+    }[extname(path).toLowerCase()];
+    return mime === undefined ? { name, mime: 'image/unknown' } : { name, mime, localPath: path };
+}
+function codexOfficialImageSources(value, sourceId) {
+    if (value.type !== 'userMessage') {
+        const path = value.type === 'imageView'
+            ? value.path
+            : value.type === 'imageGeneration'
+                ? value.savedPath
+                : undefined;
+        return typeof path === 'string' ? [codexLocalImageSource(path)] : [];
+    }
+    const images = [];
+    const paths = new Set();
+    let totalBytes = 0;
+    const content = Array.isArray(value.content) ? value.content : [];
+    for (const part of content) {
+        if (!isPlainRecord(part) || images.length >= 5)
+            continue;
+        const name = `Image #${images.length + 1}`;
+        if (part.type === 'localImage' && typeof part.path === 'string') {
+            if (!paths.has(part.path)) {
+                paths.add(part.path);
+                images.push(codexLocalImageSource(part.path, name));
+            }
+        }
+        else if (part.type === 'image') {
+            const image = codexImageAttachments([{ type: 'input_image', image_url: part.url }])[0];
+            const publicMime = image !== undefined &&
+                conversationImageAttachmentSchema.safeParse({ name, mime: image.mime }).success;
+            const byteSize = image === undefined ? 0 : Buffer.byteLength(image.dataBase64, 'base64');
+            const readable = image !== undefined &&
+                publicMime &&
+                totalBytes + byteSize <= MAX_COMPOSER_ATTACHMENTS_BYTES;
+            if (readable)
+                totalBytes += byteSize;
+            images.push(!readable || image === undefined
+                ? { name, mime: publicMime ? image.mime : 'image/unknown' }
+                : {
+                    name,
+                    mime: image.mime,
+                    byteSize,
+                    sourceId: `${sourceId}:image:${images.length}`,
+                    read: async () => ({ ...image, name })
+                });
+        }
+        else if (part.type === 'text' && typeof part.text === 'string') {
+            for (const marker of parseCodexComposerImageMarkers(part.text).images) {
+                if (images.length >= 5)
+                    break;
+                if (!paths.has(marker.localPath)) {
+                    paths.add(marker.localPath);
+                    images.push(codexLocalImageSource(marker.localPath, `Image #${marker.index}`));
+                }
+            }
+        }
+    }
+    return images;
 }
 export function codexPairedToolCallId(value) {
     if (!isPlainRecord(value))
@@ -292,7 +459,8 @@ export function coalesceImageGenerationItems(items) {
         if (item.kind !== 'tool_call' ||
             payload?.toolName !== 'imagegen' ||
             previous?.kind !== 'tool_call' ||
-            previousPayload?.toolName !== 'imagegen') {
+            previousPayload?.toolName !== 'imagegen' ||
+            previous.id !== item.id) {
             merged.push(item);
             continue;
         }
@@ -302,8 +470,14 @@ export function coalesceImageGenerationItems(items) {
         ];
         merged[merged.length - 1] = {
             ...previous,
+            status: item.status,
             completedAt: item.completedAt ?? previous.completedAt,
-            payload: { ...previousPayload, attachments }
+            payload: {
+                ...previousPayload,
+                ...payload,
+                inputSummary: previousPayload.inputSummary ?? payload.inputSummary,
+                attachments
+            }
         };
     }
     return merged;
@@ -348,15 +522,22 @@ export function codexOfficialItem(session, nativeTurnId, value, turnSequence, it
         turnId: `${session.id}:official:${nativeTurnId}`,
         runId: null,
         parentItemId: null,
-        sourceSequence: turnSequence * 10_000 + itemSequence,
+        sourceSequence: turnSequence * 10_000 + itemSequence + 1,
         revision: 0,
-        status: 'COMPLETED',
+        status: codexItemStatus(value.status, value.status !== 'inProgress'),
         startedAt,
         completedAt
     };
     if (value.type === 'userMessage') {
         const text = stripGoalStartPrompt(codexContentText(value.content));
-        return text.length === 0
+        const hasImage = Array.isArray(value.content) &&
+            value.content.some((part) => isPlainRecord(part) &&
+                (part.type === 'image' ||
+                    (part.type === 'localImage' && typeof part.path === 'string') ||
+                    (part.type === 'text' &&
+                        typeof part.text === 'string' &&
+                        parseCodexComposerImageMarkers(part.text).images.length > 0)));
+        return text.length === 0 && !hasImage
             ? undefined
             : {
                 ...base,

package/dist/runner/codex/managed-run-controller.js

@@ -409,7 +409,8 @@ export class CodexManagedRunController {
                 : {}),
             mcpServers: this.runner.mcpConfiguration(payload.mcpInstallations, {
                 ...secretEnvironment,
-                ...mcpSecretEnvironment
+                ...mcpSecretEnvironment,
+                MAR_USERNAME: secretEnvironment['MAR_USERNAME'] ?? ''
             })
         }, attachments);
     }