@myagentroam/node 0.10.10 → 0.10.11

package/dist/capabilities.js

@@ -12,6 +12,7 @@ const runtimeCredentialCapability = () => ({
     serviceTiers: ['auto', 'default', 'flex', 'priority', 'fast', 'ultrafast'],
     namespacedTools: true,
     responsesOptionalParameters: true,
+    responsesHttpContinuation: true,
     httpVersions: ['1.1', '2']
 });
 const workspaceDirectTransferCapability = () => ({

package/dist/connector.js

@@ -698,6 +698,7 @@ export class NodeConnector {
             runtime: this.runtime,
             state: this.runState,
             codex: () => this.codexClient,
+            settleCodexUsage: (runId, turnId) => this.codexRunController.settleUsage(runId, turnId),
             claude: () => this.claudeClient,
             runners: this.runners,
             emitRun: (runId, eventType, payload, status) => this.runEventBridge.emitRun(runId, eventType, payload, status),
@@ -975,7 +976,10 @@ export class NodeConnector {
                 }
             },
             migrateQueue: (previousId, nextId) => this.continuousRunCoordinator.migrateSession(previousId, nextId),
-            migrateRunnerState: (previousId, nextId) => this.runEventBridge.migrateRunnerSessionIdentity(previousId, nextId),
+            migrateRunnerState: (previousId, nextId) => {
+                this.modelUsage.promoteSession(previousId, nextId);
+                this.runEventBridge.migrateRunnerSessionIdentity(previousId, nextId);
+            },
             emitSession: (session) => this.emitSessionWorkbenchEvent({ session }),
             emitRun: (run) => this.emitWorkbenchEvent('run', { run }),
             emitQueue: (sessionId) => this.continuousRunCoordinator.publish(sessionId),

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

@@ -1,11 +1,96 @@
+import { open, stat } from 'node:fs/promises';
+import { StringDecoder } from 'node:string_decoder';
+import { nodeLog } from '../../operational.js';
 import { RunnerUsageTracker, usageToken } from '../../service/runner-usage-tracker.js';
 export class CodexUsageNormalizer {
     requestedModel;
     tracker;
+    rollout;
+    pendingRead = Promise.resolve();
+    decoder = new StringDecoder('utf8');
+    partialLine = '';
+    oversizedLine = false;
     constructor(identity, publish, requestedModel) {
         this.requestedModel = requestedModel;
         this.tracker = new RunnerUsageTracker(identity, publish);
     }
+    async attachRollout(path, threadId) {
+        await this.pendingRead;
+        this.decoder = new StringDecoder('utf8');
+        this.partialLine = '';
+        this.oversizedLine = false;
+        try {
+            // Anchor before dispatch. Inherited history and earlier requests never become new usage.
+            this.rollout = { path, threadId, offset: (await stat(path)).size };
+        }
+        catch {
+            this.reportReadFailure();
+        }
+    }
+    get hasRollout() {
+        return this.rollout !== undefined;
+    }
+    flushRollout(turnId, compact) {
+        this.pendingRead = this.pendingRead
+            .then(async () => {
+            const rollout = this.rollout;
+            if (!rollout)
+                return;
+            const file = await open(rollout.path, 'r');
+            try {
+                const end = (await file.stat()).size;
+                if (end < rollout.offset || end - rollout.offset > 16 * 1024 * 1024)
+                    throw new Error('USAGE_NATIVE_READ_LIMIT');
+                const buffer = Buffer.alloc(64 * 1024);
+                while (rollout.offset < end) {
+                    const { bytesRead } = await file.read(buffer, 0, Math.min(buffer.length, end - rollout.offset), rollout.offset);
+                    if (!bytesRead)
+                        break;
+                    rollout.offset += bytesRead;
+                    this.consumeRollout(this.decoder.write(buffer.subarray(0, bytesRead)), turnId, compact);
+                }
+            }
+            finally {
+                await file.close();
+            }
+        })
+            .catch(() => this.reportReadFailure());
+        return this.pendingRead;
+    }
+    reportReadFailure() {
+        this.rollout = undefined;
+        nodeLog('model.usage.unavailable', { runner: 'codex', code: 'USAGE_NATIVE_READ_FAILED' });
+    }
+    consumeRollout(text, turnId, compact) {
+        for (const part of text.split(/(?<=\n)/u)) {
+            if (!this.oversizedLine)
+                this.partialLine += part;
+            if (this.partialLine.length > 128 * 1024) {
+                this.partialLine = '';
+                this.oversizedLine = true;
+            }
+            if (!part.endsWith('\n'))
+                continue;
+            if (!this.oversizedLine) {
+                try {
+                    const value = JSON.parse(this.partialLine);
+                    if (isPlainRecord(value) && value.type === 'token_usage_record') {
+                        const receipt = isPlainRecord(value.payload) ? value.payload : undefined;
+                        if (receipt?.thread_id === this.rollout?.threadId && receipt?.turn_id === turnId)
+                            this.observe('rawResponse/completed', {
+                                responseId: receipt.response_id,
+                                usage: receipt.usage
+                            }, compact);
+                    }
+                }
+                catch {
+                    // Non-receipt and malformed native lines cannot turn into estimated usage.
+                }
+            }
+            this.partialLine = '';
+            this.oversizedLine = false;
+        }
+    }
     observe(method, params, compact) {
         // TokenCount.last can replay context/compaction snapshots without a request identity.
         // Only raw response completions are independently additive request facts.
@@ -15,10 +100,13 @@ export class CodexUsageNormalizer {
         const inputTokens = usageToken(usage.inputTokens ?? usage.input_tokens);
         const outputTokens = usageToken(usage.outputTokens ?? usage.output_tokens);
         const cacheReadTokens = usageToken(usage.cachedInputTokens ??
+            usage.cached_input_tokens ??
             (isPlainRecord(usage.input_tokens_details)
                 ? usage.input_tokens_details.cached_tokens
                 : undefined));
+        const cacheWriteTokens = usageToken(usage.cacheWriteInputTokens ?? usage.cache_write_input_tokens);
         const reasoningTokens = usageToken(usage.reasoningOutputTokens ??
+            usage.reasoning_output_tokens ??
             (isPlainRecord(usage.output_tokens_details)
                 ? usage.output_tokens_details.reasoning_tokens
                 : undefined));
@@ -31,6 +119,7 @@ export class CodexUsageNormalizer {
             ...(inputTokens === undefined ? {} : { inputTokens }),
             ...(outputTokens === undefined ? {} : { outputTokens }),
             ...(cacheReadTokens === undefined ? {} : { cacheReadTokens }),
+            ...(cacheWriteTokens === undefined ? {} : { cacheWriteTokens }),
             ...(reasoningTokens === undefined ? {} : { reasoningTokens })
         };
         this.tracker.snapshot(params.responseId, values, true, 'partial');

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

@@ -29,6 +29,7 @@ export class CodexManagedRunController {
     runner;
     host;
     usage = new Map();
+    finishing = new Set();
     constructor(runner, host) {
         this.runner = runner;
         this.host = host;
@@ -103,7 +104,8 @@ export class CodexManagedRunController {
         });
         this.host.emit(runId, 'run.started', { command: 'compact' }, 'STARTING');
         try {
-            await this.runner.resumeThread(threadId, session.cwd, undefined, runId);
+            const resumed = await this.runner.resumeThread(threadId, session.cwd, undefined, runId);
+            await this.attachUsageRollout(runId, resumed);
             await this.runner.request('thread/compact/start', { threadId }, runId);
             return {
                 command: 'compact',
@@ -140,12 +142,9 @@ export class CodexManagedRunController {
         if (run === undefined)
             return;
         const [runId, activeRun] = run;
-        let usage = this.usage.get(runId);
-        if (!usage) {
-            usage = new CodexUsageNormalizer(runId, (value) => this.host.emit(runId, 'run.usage', value), this.host.session(activeRun.sessionId)?.model ?? undefined);
-            this.usage.set(runId, usage);
-        }
-        usage.observe(notification.method, params, activeRun.generationCompacting === true);
+        const usage = this.usageFor(runId);
+        const compactUsage = activeRun.refreshTitle === false || activeRun.generationCompacting === true;
+        usage.observe(notification.method, params, compactUsage);
         const receiptAt = activeRun.generationTiming?.timestamp();
         if (notification.method === 'turn/started' && turnId !== undefined) {
             const active = this.runner.execution.runs.get(runId);
@@ -161,6 +160,8 @@ export class CodexManagedRunController {
             return;
         }
         if (notification.method === 'thread/tokenUsage/updated') {
+            if (turnId !== undefined)
+                void usage.flushRollout(turnId, compactUsage);
             this.completeStandardUsage(runId, params, activeRun, receiptAt);
             return;
         }
@@ -325,6 +326,8 @@ export class CodexManagedRunController {
             return;
         }
         if (notification.method === 'turn/completed') {
+            if (this.finishing.has(runId))
+                return;
             this.endPendingGenerations(activeRun, receiptAt);
             const status = turn?.status;
             const terminal = status === 'completed' ? 'SUCCEEDED' : status === 'interrupted' ? 'INTERRUPTED' : 'FAILED';
@@ -333,21 +336,60 @@ export class CodexManagedRunController {
             const failure = terminal === 'FAILED'
                 ? runnerErrorProjection(turn?.error ?? turn, 'CODEX_RUN_FAILED')
                 : { status: status ?? 'unknown' };
-            this.host.emit(runId, terminal === 'FAILED' ? 'run.failed' : 'run.completed', failure, terminal);
-            const active = this.runner.execution.runs.get(runId);
-            const titleRefresh = active === undefined ||
-                active.refreshTitle === false ||
-                this.host.session(active.sessionId)?.titleSource !== 'AUTO'
-                ? undefined
-                : this.host.syncTitle(active.sessionId, active.threadId, active.cwd);
-            this.usage.delete(runId);
-            this.runner.execution.runs.delete(runId);
-            if (titleRefresh === undefined)
-                this.runner.releaseEnvironment(runId);
+            const finish = () => {
+                if (!this.runner.execution.runs.has(runId)) {
+                    this.finishing.delete(runId);
+                    return;
+                }
+                this.host.emit(runId, terminal === 'FAILED' ? 'run.failed' : 'run.completed', failure, terminal);
+                const active = this.runner.execution.runs.get(runId);
+                const titleRefresh = active === undefined ||
+                    active.refreshTitle === false ||
+                    this.host.session(active.sessionId)?.titleSource !== 'AUTO'
+                    ? undefined
+                    : this.host.syncTitle(active.sessionId, active.threadId, active.cwd);
+                this.usage.delete(runId);
+                this.runner.execution.runs.delete(runId);
+                if (titleRefresh === undefined)
+                    this.runner.releaseEnvironment(runId);
+                else
+                    void titleRefresh.finally(() => this.runner.releaseEnvironment(runId));
+                this.host.removeActive(runId);
+                this.finishing.delete(runId);
+            };
+            if (usage.hasRollout && turnId !== undefined) {
+                this.finishing.add(runId);
+                void this.settleUsage(runId, turnId).then(finish);
+            }
             else
-                void titleRefresh.finally(() => this.runner.releaseEnvironment(runId));
-            this.host.removeActive(runId);
+                finish();
+        }
+    }
+    async settleUsage(runId, turnId) {
+        const usage = this.usage.get(runId);
+        const active = this.runner.execution.runs.get(runId);
+        if (usage) {
+            await usage.flushRollout(turnId, active?.refreshTitle === false || active?.generationCompacting === true);
+            if (this.usage.get(runId) === usage)
+                this.usage.delete(runId);
+        }
+    }
+    usageFor(runId) {
+        let usage = this.usage.get(runId);
+        if (!usage) {
+            const active = this.runner.execution.runs.get(runId);
+            usage = new CodexUsageNormalizer(runId, (value) => this.host.emit(runId, 'run.usage', {
+                ...value,
+                sessionId: this.runner.execution.runs.get(runId)?.threadId
+            }), active ? (this.host.session(active.sessionId)?.model ?? undefined) : undefined);
+            this.usage.set(runId, usage);
         }
+        return usage;
+    }
+    async attachUsageRollout(runId, result) {
+        const thread = isPlainRecord(result) && isPlainRecord(result.thread) ? result.thread : undefined;
+        if (typeof thread?.path === 'string' && typeof thread.id === 'string')
+            await this.usageFor(runId).attachRollout(thread.path, thread.id);
     }
     observeResponse(runId, itemId, incremental = false) {
         const latencyMs = this.runner.execution.runs
@@ -629,6 +671,7 @@ export class CodexManagedRunController {
                         generationResponseIds: new Map(),
                         completedGenerationResponseIds: new Set()
                     });
+                    await this.attachUsageRollout(runId, threadResult);
                     turnResult = await this.runner.startTurn(threadId, input, cwd, turnConfiguration, materializedAttachments, runId);
                     break;
                 }

package/dist/service/model-usage-service.js

@@ -36,6 +36,11 @@ export class NodeModelUsageService {
     release(runId) {
         this.bindings.delete(runId);
     }
+    promoteSession(previousId, nextId) {
+        for (const [runId, binding] of this.bindings)
+            if (binding.sessionId === previousId)
+                this.bindings.set(runId, { ...binding, sessionId: nextId });
+    }
     clear() {
         this.bindings.clear();
     }

package/dist/service/runner-interaction-service.js

@@ -147,16 +147,22 @@ export class RunnerInteractionService {
     }
     async cancelCodexTurn(runId, threadId, turnId, cwd, terminalStatus) {
         const codex = this.options.codex();
+        let failed = false;
         try {
             await codex.interruptTurn(threadId, turnId, runId);
-            const run = this.options.runtime.getRun(runId);
-            if (run !== undefined && !isTerminalRunStatus(run.status))
-                this.options.emitRun(runId, 'run.completed', { status: terminalStatus }, terminalStatus);
         }
         catch {
+            failed = true;
+        }
+        try {
+            await this.options.settleCodexUsage(runId, turnId);
             const run = this.options.runtime.getRun(runId);
-            if (run !== undefined && !isTerminalRunStatus(run.status))
-                this.options.emitRun(runId, 'run.failed', { code: 'CODEX_INTERRUPT_FAILED' }, 'FAILED');
+            if (run !== undefined && !isTerminalRunStatus(run.status)) {
+                if (failed)
+                    this.options.emitRun(runId, 'run.failed', { code: 'CODEX_INTERRUPT_FAILED' }, 'FAILED');
+                else
+                    this.options.emitRun(runId, 'run.completed', { status: terminalStatus }, terminalStatus);
+            }
         }
         finally {
             codex.execution.runs.delete(runId);

package/dist/service/session-lifecycle-service.js

@@ -198,6 +198,10 @@ export class SessionLifecycleService {
                             sessionId: bootstrapId,
                             commandId: value.commandId,
                             input: value.input,
+                            ...(input.__requestUserId === undefined
+                                ? {}
+                                : { __requestUserId: input.__requestUserId }),
+                            ...(input.__usageGrant === undefined ? {} : { __usageGrant: input.__usageGrant }),
                             ...(input.secretEnvironment === undefined
                                 ? {}
                                 : { secretEnvironment: input.secretEnvironment })
@@ -211,6 +215,7 @@ export class SessionLifecycleService {
                 clientMessageId: input.clientMessageId,
                 content: input.content,
                 ...(input.__requestUserId === undefined ? {} : { __requestUserId: input.__requestUserId }),
+                ...(input.__usageGrant === undefined ? {} : { __usageGrant: input.__usageGrant }),
                 ...(input.secretEnvironment === undefined
                     ? {}
                     : { secretEnvironment: input.secretEnvironment }),

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/node",
-  "version": "0.10.10",
+  "version": "0.10.11",
   "description": "MyAgentRoam Node runtime CLI.",
   "license": "Apache-2.0 AND GPL-2.0-or-later",
   "type": "module",
@@ -37,9 +37,9 @@
     "playwright": "1.62.1",
     "ws": "^8.21.3",
     "zod": "4.4.3",
-    "@myagentroam/agent": "0.10.10",
+    "@myagentroam/agent": "0.10.11",
     "@myagentroam/code-navigation": "0.10.1",
-    "@myagentroam/protocol": "0.10.10",
+    "@myagentroam/protocol": "0.10.11",
     "@myagentroam/marctl": "0.10.2"
   },
   "devDependencies": {