@myagentroam/node 0.10.7 → 0.10.8

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

@@ -0,0 +1,167 @@
+import { MODEL_USAGE_BATCH_BYTES, MODEL_USAGE_BATCH_LIMIT, MODEL_USAGE_OUTBOX_RETENTION_MS, modelUsageAckSchema, modelUsageGrantSchema, modelUsageRecordSchema } from '@myagentroam/protocol';
+const MAX_BYTES = 32 * 1024 * 1024;
+/** Durable, bounded, at-least-once delivery independent of browser subscriptions. */
+export class ModelUsageOutbox {
+    options;
+    enabled = false;
+    timer;
+    inFlight;
+    attempts = 0;
+    now;
+    constructor(options) {
+        this.options = options;
+        this.now = options.now ?? Date.now;
+    }
+    connected(payload) {
+        this.disconnected();
+        const capability = payload?.modelUsage;
+        this.enabled = capability?.apiVersion === 1;
+        if (this.enabled) {
+            this.recover();
+            this.schedule(0);
+        }
+    }
+    disconnected() {
+        this.enabled = false;
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = undefined;
+        this.inFlight = undefined;
+        this.attempts = 0;
+    }
+    record(grant, value) {
+        try {
+            const database = this.options.database();
+            const namespace = this.options.namespace();
+            if (!database || !namespace)
+                return;
+            const record = modelUsageRecordSchema.parse(value);
+            const parsedGrant = modelUsageGrantSchema.parse(grant);
+            const payload = JSON.stringify({ grant: parsedGrant, record });
+            const bytes = Buffer.byteLength(payload);
+            this.expire(database);
+            const current = database
+                .prepare('SELECT revision,bytes FROM model_usage_outbox WHERE namespace=? AND record_id=?')
+                .get(namespace, record.recordId);
+            if (current && Number(current.revision) >= record.revision)
+                return;
+            const total = Number(database.prepare('SELECT COALESCE(SUM(bytes),0) AS bytes FROM model_usage_outbox').get()
+                ?.bytes ?? 0);
+            if (bytes > MODEL_USAGE_BATCH_BYTES / 2 ||
+                total - Number(current?.bytes ?? 0) + bytes > MAX_BYTES) {
+                this.options.diagnose('USAGE_OUTBOX_FULL');
+                return;
+            }
+            database
+                .prepare(`INSERT INTO model_usage_outbox(namespace,record_id,revision,payload,bytes,updated_at,ended_at) VALUES (?,?,?,?,?,?,?)
+        ON CONFLICT(namespace,record_id) DO UPDATE SET revision=excluded.revision,payload=excluded.payload,bytes=excluded.bytes,updated_at=excluded.updated_at,ended_at=excluded.ended_at`)
+                .run(namespace, record.recordId, record.revision, payload, bytes, this.now(), record.endedAt ?? null);
+            if (this.enabled && !this.inFlight && !this.timer)
+                this.schedule(250);
+        }
+        catch {
+            this.options.diagnose('USAGE_OUTBOX_WRITE_FAILED');
+        }
+    }
+    handle(envelope) {
+        if (envelope.type !== 'usage.ack')
+            return false;
+        const parsed = modelUsageAckSchema.safeParse(envelope.payload);
+        const namespace = this.options.namespace();
+        const database = this.options.database();
+        if (!parsed.success || !this.inFlight || !namespace || !database)
+            return true;
+        try {
+            for (const result of parsed.data.results) {
+                if (this.inFlight.get(result.recordId) !== result.revision)
+                    continue;
+                database
+                    .prepare('DELETE FROM model_usage_outbox WHERE namespace=? AND record_id=? AND revision=?')
+                    .run(namespace, result.recordId, result.revision);
+                if (result.status === 'rejected')
+                    this.options.diagnose(result.code ?? 'USAGE_REJECTED');
+            }
+            this.inFlight = undefined;
+            this.attempts = 0;
+            this.schedule(250);
+        }
+        catch {
+            this.options.diagnose('USAGE_OUTBOX_ACK_FAILED');
+        }
+        return true;
+    }
+    schedule(delay) {
+        if (this.timer)
+            clearTimeout(this.timer);
+        this.timer = setTimeout(() => {
+            this.timer = undefined;
+            this.flush();
+        }, delay);
+        this.timer.unref();
+    }
+    flush() {
+        const database = this.options.database();
+        const namespace = this.options.namespace();
+        if (!this.enabled || !database || !namespace)
+            return;
+        try {
+            this.expire(database);
+            const rows = database
+                .prepare('SELECT payload FROM model_usage_outbox WHERE namespace=? AND ended_at IS NOT NULL ORDER BY updated_at,record_id LIMIT ?')
+                .all(namespace, MODEL_USAGE_BATCH_LIMIT);
+            const entries = [];
+            let bytes = 100;
+            for (const row of rows) {
+                bytes += Buffer.byteLength(String(row.payload)) + 1;
+                if (bytes > MODEL_USAGE_BATCH_BYTES)
+                    break;
+                entries.push(JSON.parse(String(row.payload)));
+            }
+            if (!entries.length) {
+                this.inFlight = undefined;
+                return;
+            }
+            this.inFlight = new Map(entries.map(({ record }) => [record.recordId, record.revision]));
+            this.options.send('usage.batch', { apiVersion: 1, entries });
+            this.schedule(Math.min(60_000, 1000 * 2 ** Math.min(this.attempts++, 6)));
+        }
+        catch {
+            this.options.diagnose('USAGE_OUTBOX_SEND_FAILED');
+            this.schedule(30_000);
+        }
+    }
+    recover() {
+        const database = this.options.database();
+        const namespace = this.options.namespace();
+        if (!database || !namespace)
+            return;
+        // Reconnect must not finalize requests that are still running.
+        this.expire(database);
+    }
+    recoverInterrupted() {
+        const database = this.options.database();
+        const namespace = this.options.namespace();
+        if (!database || !namespace)
+            return;
+        this.expire(database);
+        const rows = database
+            .prepare('SELECT payload FROM model_usage_outbox WHERE namespace=? AND ended_at IS NULL')
+            .all(namespace);
+        for (const row of rows) {
+            const entry = JSON.parse(String(row.payload));
+            this.record(entry.grant, {
+                ...entry.record,
+                revision: entry.record.revision + 1,
+                state: 'interrupted',
+                endedAt: Math.max(entry.record.startedAt, this.now())
+            });
+        }
+    }
+    expire(database) {
+        const result = database
+            .prepare('DELETE FROM model_usage_outbox WHERE updated_at<?')
+            .run(this.now() - MODEL_USAGE_OUTBOX_RETENTION_MS);
+        if (result.changes)
+            this.options.diagnose('USAGE_OUTBOX_EXPIRED');
+    }
+}

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

@@ -0,0 +1,61 @@
+import { modelUsageGrantSchema, modelUsageGrantClaimsSchema, modelUsageRecordSchema } from '@myagentroam/protocol';
+import { nodeLog } from '../operational.js';
+import { AsyncLocalStorage } from 'node:async_hooks';
+/** Execution-private attribution never enters Run projections or browser Watch events. */
+export class NodeModelUsageService {
+    outbox;
+    nodeId;
+    scope = new AsyncLocalStorage();
+    bindings = new Map();
+    constructor(outbox, nodeId) {
+        this.outbox = outbox;
+        this.nodeId = nodeId;
+    }
+    withGrant(grant, action) {
+        return this.scope.run(grant, action);
+    }
+    bindInherited(runId, sessionId, runner) {
+        if (!this.bindings.has(runId))
+            this.bind(runId, this.scope.getStore(), sessionId, runner);
+    }
+    bind(runId, grant, sessionId, runner) {
+        this.bindings.delete(runId);
+        if (grant === undefined)
+            return;
+        try {
+            const parsedGrant = modelUsageGrantSchema.parse(grant);
+            const claims = modelUsageGrantClaimsSchema.parse(JSON.parse(Buffer.from(parsedGrant.token.split('.')[0], 'base64url').toString()));
+            if (claims.nodeId !== this.nodeId() || claims.scopeId !== parsedGrant.scopeId)
+                return;
+            this.bindings.set(runId, { grant: parsedGrant, scopeId: claims.scopeId, sessionId, runner });
+        }
+        catch {
+            nodeLog('model.usage.invalid', { code: 'USAGE_GRANT_INVALID' });
+        }
+    }
+    release(runId) {
+        this.bindings.delete(runId);
+    }
+    clear() {
+        this.bindings.clear();
+    }
+    record(runId, value) {
+        const binding = this.bindings.get(runId);
+        if (!binding || !value || typeof value !== 'object')
+            return;
+        const parsed = modelUsageRecordSchema.safeParse({
+            ...value,
+            scopeId: binding.scopeId,
+            runner: binding.runner,
+            runId,
+            sessionId: typeof value.sessionId === 'string'
+                ? value.sessionId
+                : binding.sessionId
+        });
+        if (!parsed.success) {
+            nodeLog('model.usage.invalid', { code: 'USAGE_RECORD_INVALID' });
+            return;
+        }
+        this.outbox()?.record(binding.grant, parsed.data);
+    }
+}

package/dist/service/node-control-message-service.js

@@ -22,7 +22,7 @@ export class NodeControlMessageService {
             return;
         }
         if (envelope.type === 'authenticated') {
-            this.options.connected();
+            this.options.connected(envelope.payload);
             return;
         }
         if (envelope.type === 'workspace.inspect') {
@@ -45,6 +45,10 @@ export class NodeControlMessageService {
         if (envelope.type.startsWith('terminal.direct.') &&
             this.options.handleTerminalDirect?.(envelope) === true)
             return;
+        if (envelope.type === 'usage.ack') {
+            this.options.usageAck?.(envelope.payload);
+            return;
+        }
         if (envelope.type === 'ack')
             return;
         if (envelope.type === 'runs.reconcile') {
@@ -58,6 +62,7 @@ export class NodeControlMessageService {
         if (envelope.type === 'run.start') {
             this.options.send('ack', { type: envelope.type }, envelope.id);
             try {
+                this.options.bindUsage?.(envelope.payload);
                 this.options.runners.startManagedRun(envelope);
             }
             catch (error) {
@@ -90,7 +95,7 @@ export class NodeControlMessageService {
             this.options.close(4002, 'MESSAGE_INVALID');
             return;
         }
-        void this.options.register(payload.nodeId, payload.credential);
+        void this.options.register(payload.nodeId, payload.credential, envelope.payload);
     }
     decideApproval(envelope) {
         const payload = envelope.payload;

package/dist/service/node-request-service.js

@@ -19,12 +19,14 @@ export class NodeRequestService {
         }
         const startedAt = performance.now();
         try {
+            const usageGrant = payload.userAuthorization.usageGrant;
             const data = payload.data !== null && typeof payload.data === 'object'
                 ? {
                     ...payload.data,
                     __workspaceWatchSessionHash: payload.userAuthorization
                         .sessionHash,
-                    __requestUserId: payload.userAuthorization.userId
+                    __requestUserId: payload.userAuthorization.userId,
+                    ...(usageGrant === undefined ? {} : { __usageGrant: usageGrant })
                 }
                 : payload.data;
             const result = await this.options.execute(payload.operation, data);

package/dist/service/node-run-event-bridge.js

@@ -113,6 +113,12 @@ export class NodeRunEventBridge {
         this.emitRun(input.runId, 'approval.request', input);
     }
     emitRun(runId, eventType, payload, status) {
+        if (eventType === 'run.started')
+            this.options.bindModelUsage?.(runId);
+        if (eventType === 'run.usage') {
+            this.options.modelUsage?.(runId, payload);
+            return;
+        }
         this.options.events.emit(runId, eventType, payload, status);
     }
     emitQueue(workspaceId, sessionId) {

package/dist/service/runner-usage-tracker.js

@@ -0,0 +1,62 @@
+import { createHash } from 'node:crypto';
+export function usageToken(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0
+        ? String(value)
+        : undefined;
+}
+export function usageTokenSum(...values) {
+    return values.some((value) => value === undefined)
+        ? undefined
+        : values.reduce((sum, value) => sum + BigInt(value), 0n).toString();
+}
+/** Neutral revision tracking; native token semantics remain inside each Runner normalizer. */
+export class RunnerUsageTracker {
+    identity;
+    publish;
+    now;
+    records = new Map();
+    constructor(identity, publish, now = Date.now) {
+        this.identity = identity;
+        this.publish = publish;
+        this.now = now;
+    }
+    snapshot(id, values, complete, coverage = 'request') {
+        const previous = this.records.get(id);
+        const timestamp = this.now();
+        const recordId = createHash('sha256')
+            .update(JSON.stringify([this.identity, id]))
+            .digest('hex');
+        const record = {
+            ...previous,
+            ...values,
+            schemaVersion: 1,
+            recordId,
+            requestId: recordId,
+            revision: (previous?.revision ?? 0) + 1,
+            startedAt: previous?.startedAt ?? timestamp,
+            state: complete ? 'succeeded' : (previous?.state ?? 'running'),
+            coverage,
+            ...(complete ? { endedAt: previous?.endedAt ?? timestamp } : {})
+        };
+        if (previous &&
+            JSON.stringify({ ...record, revision: 0 }) === JSON.stringify({ ...previous, revision: 0 }))
+            return;
+        this.records.set(id, record);
+        if (!previous || record.state !== 'running')
+            this.publish(record);
+    }
+    finish(state) {
+        for (const [id, previous] of this.records) {
+            if (previous.state !== 'running')
+                continue;
+            const record = {
+                ...previous,
+                revision: previous.revision + 1,
+                state,
+                endedAt: Math.max(previous.startedAt, this.now())
+            };
+            this.records.set(id, record);
+            this.publish(record);
+        }
+    }
+}

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

@@ -1,3 +1,4 @@
+import { modelUsageGrantSchema } from '@myagentroam/protocol';
 import { parseCommandInvocation } from '../runner-command-engine.js';
 import { isPlainRecord } from '../util/node-operation-parsers.js';
 import { parseSecretEnvironment } from '../util/secret-environment.js';
@@ -66,6 +67,9 @@ export class SessionCommandService {
             return this.options.goal({
                 session,
                 objective: invocation.argument,
+                ...(input.__usageGrant === undefined
+                    ? {}
+                    : { usageGrant: modelUsageGrantSchema.parse(input.__usageGrant) }),
                 ...(Number.isSafeInteger(input.__requestUserId)
                     ? { initiatedByUserId: input.__requestUserId }
                     : {}),

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

@@ -1,3 +1,4 @@
+import { modelUsageGrantSchema } from '@myagentroam/protocol';
 import { randomUUID } from 'node:crypto';
 import { isImageAttachment, isRunnerImageAttachment, parseComposerAttachmentIds, parseMessageAttachments, sessionTitleFromFirstMessage, withNonImageAttachmentPrompt } from '../util/node-operation-parsers.js';
 import { parseSecretEnvironment } from '../util/secret-environment.js';
@@ -41,6 +42,7 @@ export class SessionMessageService {
             marAgentModel: input.marAgentModel,
             marAgentModels: input.marAgentModels,
             marAgentCompact: input.marAgentCompact,
+            __usageGrant: input.usageGrant,
             marAgentRuntimeScopeId: input.marAgentRuntimeScopeId
         });
     }
@@ -58,6 +60,7 @@ export class SessionMessageService {
             marAgentModel: input.marAgentModel,
             marAgentModels: input.marAgentModels,
             marAgentCompact: input.marAgentCompact,
+            __usageGrant: input.usageGrant,
             marAgentRuntimeScopeId: input.marAgentRuntimeScopeId
         });
     }
@@ -188,6 +191,9 @@ export class SessionMessageService {
                     else
                         this.options.runtime.updateQueueItemAttachments(created.queueItem.id, attachments, displayInput);
                     this.options.coordinator.prepare(submissionId, {
+                        ...(input.__usageGrant === undefined
+                            ? {}
+                            : { usageGrant: modelUsageGrantSchema.parse(input.__usageGrant) }),
                         runId,
                         sessionId: currentSession.id,
                         workspaceId: currentSession.workspaceId,

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

@@ -1,4 +1,5 @@
 import { isPlainRecord } from '../runner/codex/conversation-parser.js';
+import { toolResultResourceInputSchema, toolResultResourcePageSchema } from '@myagentroam/protocol';
 export class SessionQueryService {
     options;
     constructor(options) {
@@ -11,6 +12,7 @@ export class SessionQueryService {
             'session.turns.list': (data) => this.turns(record(data)),
             'session.events.read': (data) => this.events(record(data)),
             'session.context.read': (data) => this.readContext(record(data)),
+            'session.tool-resource.read': (data) => this.readToolResource(record(data)),
             'session.discover': (data) => this.discover(record(data))
         };
     }
@@ -39,6 +41,20 @@ export class SessionQueryService {
             throw new Error('SESSION_NOT_FOUND');
         return this.options.runtime.listConversationItems({ sessionId: session.id, ...page });
     }
+    async readToolResource(input) {
+        const session = await this.requireSession(input.sessionId);
+        if (typeof input.workspaceId !== 'string' || input.workspaceId !== session.workspaceId)
+            throw new Error('SESSION_NOT_FOUND');
+        const resource = toolResultResourceInputSchema.parse({
+            resourceRef: input.resourceRef,
+            cursor: input.cursor,
+            maxBytes: input.maxBytes
+        });
+        const runner = this.options.runners.product(session.runner);
+        if (!runner)
+            throw new Error('TOOL_RESOURCE_UNSUPPORTED');
+        return toolResultResourcePageSchema.parse(await runner.readToolResultResource(session, resource));
+    }
     async readContext(input) {
         return this.options.context.read(await this.requireSession(input.sessionId));
     }

package/dist/util/node-operation-parsers.js

@@ -160,27 +160,6 @@ export function extractClaudeToolUses(message) {
         ];
     });
 }
-export function extractClaudeToolResults(message) {
-    const parentId = typeof message.parent_tool_use_id === 'string' ? message.parent_tool_use_id : null;
-    const direct = compactRunnerValue(message.tool_use_result, 10_000);
-    if (parentId !== null && direct.text.length > 0)
-        return [
-            { toolUseId: parentId, output: direct.text, failed: false, truncated: direct.truncated }
-        ];
-    return claudeContentBlocks(message).flatMap((block) => {
-        if (block.type !== 'tool_result' || typeof block.tool_use_id !== 'string')
-            return [];
-        const result = compactRunnerValue(block.content, 10_000);
-        return [
-            {
-                toolUseId: block.tool_use_id,
-                output: result.text,
-                failed: block.is_error === true,
-                truncated: result.truncated
-            }
-        ];
-    });
-}
 export function claudeContentBlocks(message) {
     const content = message.message;
     if (!isPlainRecord(content) || !Array.isArray(content.content))

package/dist/util/runner-native-session-parsers.js

@@ -4,7 +4,7 @@ import { stripClaudePlanTag } from '../runner-command-engine.js';
 import { publicGoalHistoryText } from '../service/goal-runtime.js';
 import { parseCodexComposerImageMarkers } from '../runner/codex/composer-image-markers.js';
 import { normalizeCodexTool } from '../runner/codex/tool-normalizer.js';
-import { normalizeClaudeTool } from '../runner/claude/tool-normalizer.js';
+import { normalizeClaudeTool, restoreClaudeSubagentTitles } from '../runner/claude/tool-normalizer.js';
 import { compactRunnerText, isPlainRecord, nativePageEnd } from './node-operation-parsers.js';
 export function extractId(result, key) {
     if (typeof result === 'object' &&
@@ -148,6 +148,11 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
     const nativeTurnIds = nativeTranscriptTurnIds(session.id, nativeTurns);
     const end = nativePageEnd(effectiveCursor, session.id, nativeTurns.length);
     const start = Math.max(0, end - limit);
+    const knownClaudeSubagents = restoreClaudeSubagentTitles(session.runner === 'claude-code'
+        ? history.items
+            .slice(0, nativeTurns[start]?.[0]?.index ?? 0)
+            .filter((entry) => entry.kind === 'tool_call')
+        : []);
     const nativePageTurns = nativeTurns
         .slice(start, end)
         .map((entries, relativeIndex) => {
@@ -161,7 +166,7 @@ export function nativeConversationPage(session, history, input, runtimeTurns = [
         const turnId = runtimeTurn?.id ?? nativeTurnIds[start + relativeIndex];
         const itemIdentities = nativeTranscriptItemIdentities(entries);
         const nativeItems = entries.map(({ entry, index }, entryIndex) => ({
-            ...nativeTranscriptConversationItem(session, entry, index, itemIdentities[entryIndex], turnId, runtimeTurns, registerImages),
+            ...nativeTranscriptConversationItem(session, entry, index, itemIdentities[entryIndex], turnId, runtimeTurns, registerImages, knownClaudeSubagents),
             runId: runtimeTurn?.runId ?? null
         }));
         const runtimeErrors = (runtimeTurn?.items ?? [])
@@ -299,14 +304,14 @@ function nativeTranscriptTurns(items) {
         turns.push(current);
     return turns;
 }
-function nativeTranscriptConversationItem(session, entry, index, itemIdentity, turnId, runtimeTurns, registerImages) {
+function nativeTranscriptConversationItem(session, entry, index, itemIdentity, turnId, runtimeTurns, registerImages, knownClaudeSubagents) {
     const time = entry.createdAt;
     const isToolCall = entry.kind === 'tool_call';
     const isUnknown = entry.kind === 'unknown';
     const isReasoning = entry.kind === 'reasoning_summary';
     const isContextCompaction = entry.kind === 'context_compaction';
     const normalizedClaudeTool = session.runner === 'claude-code' && isToolCall
-        ? normalizeClaudeTool(entry.toolName, entry.input, entry.outputSummary, entry.failed, entry.inputTruncated || entry.outputTruncated)
+        ? normalizeClaudeTool(entry.toolName, entry.input, entry.outputSummary, entry.failed, entry.inputTruncated || entry.outputTruncated, knownClaudeSubagents, entry.claudeResult)
         : undefined;
     const normalizedCodexTool = session.runner === 'codex' && isToolCall
         ? normalizeCodexTool({

package/package.json

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