@myagentroam/node 0.10.20 → 0.10.22

package/dist/capabilities.js

@@ -13,6 +13,7 @@ const runtimeCredentialCapability = () => ({
     namespacedTools: true,
     responsesOptionalParameters: true,
     responsesHttpContinuation: true,
+    conversationModels: true,
     httpVersions: ['1.1', '2']
 });
 const workspaceDirectTransferCapability = () => ({
@@ -56,6 +57,7 @@ export function unavailableCapabilities() {
         openCode: { available: false },
         marAgent: { available: true, version: nodeAppVersion },
         marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        promptCompletion: { apiVersion: 1, contextVersion: 3, automaticTriggers: true },
         chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
         terminalDirect: terminalDirectCapability()
@@ -91,6 +93,7 @@ export function detectCapabilities(commands = {}) {
         },
         marAgent: { available: true, version: nodeAppVersion },
         marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        promptCompletion: { apiVersion: 1, contextVersion: 3, automaticTriggers: true },
         chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
         terminalDirect: terminalDirectCapability()
@@ -130,6 +133,7 @@ export async function detectCapabilitiesAsync(commands = {}) {
         },
         marAgent: { available: true, version: nodeAppVersion },
         marAgentRuntimeCredentials: runtimeCredentialCapability(),
+        promptCompletion: { apiVersion: 1, contextVersion: 3, automaticTriggers: true },
         chatgptLogin: { apiVersion: 1, loopback: true },
         workspaceDirectTransfer: workspaceDirectTransferCapability(),
         terminalDirect: terminalDirectCapability()

package/dist/connector.js

@@ -102,6 +102,8 @@ import { ComputerUseEnablementService } from './service/computer-use-enablement-
 import { safeErrorCode } from './util/safe-error.js';
 import { RuntimeCredentialControlService } from './service/runtime-credential-control-service.js';
 import { MarAgentRuntimeModelFactory } from './runner/mar-agent/runtime-model-factory.js';
+import { PromptCompletionNodeService } from './service/prompt-completion-node-service.js';
+import { PromptCompletionWorkspaceSource } from './service/prompt-completion-workspace-source.js';
 import { MarAgentModelTransportTestService } from './service/mar-agent-model-transport-test-service.js';
 import { ChatgptLoginService } from './service/chatgpt-login-service.js';
 const HEARTBEAT_MS = 15_000;
@@ -219,6 +221,7 @@ export class NodeConnector {
     sessionIdentityService;
     nativeSessionProjectionService;
     conversationHistoryService;
+    promptCompletion;
     conversationSegmentService;
     runnerInteractionService;
     runnerChannelMessages;
@@ -1191,13 +1194,17 @@ export class NodeConnector {
             nativeIds: (session) => this.nativeSessionProjectionService.nativeIds(session),
             forget: (session, nativeIds) => {
                 this.nativeSessionProjectionService.forget(session, nativeIds);
+                this.promptCompletion.invalidateSession(session.workspaceId, session.id);
                 void this.runAttachmentService.releaseSession(session.id);
             },
             refreshActivity: (session) => this.conversationHistoryService.refreshExternalActivity(session),
             externalActivity: (sessionId) => this.sessionState.externalActivity.get(sessionId),
             isWatching: (sessionId) => this.nativeSessionWatchService.isWatching(sessionId),
             history: (session, input) => this.conversationHistoryService.read(session, input),
-            invalidateHistory: (sessionId) => this.nativeSessionWatchService.invalidate(sessionId),
+            invalidateHistory: (sessionId, workspaceId) => {
+                this.nativeSessionWatchService.invalidate(sessionId);
+                this.promptCompletion.invalidateSession(workspaceId, sessionId);
+            },
             invalidateWorkspaceSessions: (workspaceId) => {
                 this.workspaceSessionService.invalidateCache(workspaceId);
                 void this.workspaceWorkbenchService?.invalidateTopic(workspaceId, 'sessions');
@@ -1297,6 +1304,7 @@ export class NodeConnector {
             onReconnectScheduled: () => this.metrics.reconnectScheduled(),
             onMessage: (raw) => this.handleMessage(raw),
             onClose: (code, reason) => {
+                this.promptCompletion?.disconnect();
                 this.usageOutbox?.disconnected();
                 this.directTransferService?.close();
                 this.runtimeCredentials.disconnected();
@@ -1477,6 +1485,7 @@ export class NodeConnector {
             this.workspaceCoordinator.invalidateChanges(workspaceId);
             this.workspaceSessionService.invalidate(workspaceId);
             this.workspaceCoordinator.clearWatches(workspaceId);
+            this.promptCompletion?.invalidateWorkspace(workspaceId);
         });
         this.workspaceWorkbenchService = new WorkspaceWorkbenchService({
             requireWorkspace: (workspaceId) => this.workspaceCoordinator.require(workspaceId),
@@ -1496,6 +1505,53 @@ export class NodeConnector {
             nodeGeneration: () => this.nodeGeneration,
             emitWatchEvent: (payload) => this.send('watch.event', payload)
         });
+        const completionWorkspace = new PromptCompletionWorkspaceSource({
+            requireWorkspace: (workspaceId) => this.workspaceCoordinator.require(workspaceId),
+            observesWorkspace: (workspaceId, actor, connectionId) => this.workspaceWatchService.observes(workspaceId, actor.sessionHash, connectionId),
+            observesSession: (workspaceId, sessionId, actor, connectionId) => this.nativeSessionWatchService.observes(actor.sessionHash, connectionId, workspaceId, sessionId),
+            resolveSession: (sessionId) => this.nativeSessionProjectionService.resolve(sessionId),
+            cachedSessions: (workspaceId) => this.workspaceState.sessionCache.get(workspaceId)?.sessions ?? [],
+            readHistory: (session, limit) => this.conversationHistoryService.read(session, { limit })
+        });
+        this.promptCompletion = new PromptCompletionNodeService({
+            generation: () => this.nodeGeneration,
+            readAttentionFile: (input, _actor, event) => {
+                return this.workspaceWorkbenchService.readPredictionFile(input.target.workspaceId, event.path, event.worktreePath);
+            },
+            taskState: (input) => {
+                const id = input.sessionId;
+                if (!id || !this.runtime.getAgentSession(id))
+                    return { goal: 'UNKNOWN', queue: 'UNKNOWN' };
+                const queue = this.runtime.sessionQueue(id);
+                const run = this.runtime.activeSessionRun(id) ?? this.runtime.listRunsForSession(id)[0];
+                const goal = this.goalRuntime.get(id);
+                return {
+                    ...(run ? { runStatus: run.status } : {}),
+                    goal: goal
+                        ? {
+                            id: goal.id,
+                            objective: goal.objective,
+                            status: goal.status,
+                            revision: goal.revision
+                        }
+                        : null,
+                    queue: {
+                        version: queue.version,
+                        paused: queue.paused,
+                        items: queue.itemIds.flatMap((itemId) => {
+                            const item = this.runtime.getQueueItem(itemId);
+                            return item ? [{ queueItemId: item.id, content: item.content }] : [];
+                        })
+                    }
+                };
+            },
+            modelFactory: this.marAgentRuntimeModels,
+            usage: this.modelUsage,
+            observed: (input, actor) => completionWorkspace.observed(input, actor),
+            readPage: (input, actor, signal) => completionWorkspace.readPage(input, actor, signal),
+            references: (workspaceId, _actor, signal) => completionWorkspace.references(workspaceId, signal)
+        });
+        this.operationRouter.registerAll(this.promptCompletion.operations());
         for (const operation of CONVERSATION_TEMPLATE_OPERATIONS)
             this.operationRouter.register(operation, (data) => {
                 const handler = this.conversationTemplateOperations?.[operation];
@@ -1726,6 +1782,7 @@ export class NodeConnector {
         this.stopping = undefined;
         this.stopped = false;
         this.config ??= await loadNodeConfig(this.configPath);
+        this.promptCompletion.initializeJournal(nodeDataDirectory(this.config, this.configPath));
         await this.upgradeCoordinator.loadResult(resolve(dirname(nodeDatabasePath(this.config, this.configPath)), 'upgrade-result.json'));
         await assertLocalSqlitePath(nodeDatabasePath(this.config, this.configPath));
         this.database ??= new NodeDatabase(nodeDatabasePath(this.config, this.configPath), () => this.config?.nodeId ?? 'unregistered');
@@ -2083,6 +2140,7 @@ export class NodeConnector {
         }
         this.claudeClient.execution.userInputs.clear();
         this.nativeSessionWatchService.clear();
+        this.promptCompletion.dispose();
         this.sessionIdentityService.dispose();
         this.sessionLifecycleService.clear();
         this.continuousRunCoordinator.clear();

package/dist/runner/mar-agent/runtime-model-factory.js

@@ -62,6 +62,7 @@ export class MarAgentRuntimeModelFactory {
                     outputCapabilities: configuration.outputCapabilities,
                     reasoningEfforts: configuration.reasoningEfforts,
                     defaultReasoningEffort: resolveMarAgentDefaultReasoningEffort(configuration.defaultReasoningEffort, configuration.reasoningEfforts),
+                    conversationModel: configuration.conversationModel ?? true,
                     titleGeneration: configuration.titleGeneration,
                     codeMode: configuration.codeMode,
                     ...(configuration.serviceTier === undefined

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

@@ -95,7 +95,7 @@ export class MarAgentRunner extends AbstractRunner {
         return capabilities.marAgent?.available === true;
     }
     profileForValidation() {
-        const models = this.#models.filter((model) => model.enabled);
+        const models = this.#models.filter((model) => model.enabled && model.conversationModel !== false);
         return {
             runner: 'mar-agent',
             models: models.map((model, index) => ({

package/dist/service/hosted-conversation-node-service.js

@@ -259,8 +259,10 @@ export class HostedConversationNodeService {
             : this.latestAvailableTemplateVersionId(conversation.templateId);
         const displayVersionId = latestVersionId ?? conversation.activeVersionId;
         const version = await this.loadTemplateVersion(displayVersionId, conversation.templateId);
-        const models = networkModels(allowedModels(version, availableModels), version.draft.networkMode);
-        if (models.length > 0) {
+        const models = networkModels(allowedModels(version, availableModels), version.draft.networkMode).filter((model) => model.conversationModel !== false);
+        if (models.length > 0 &&
+            availableModels.find((model) => model.id === conversation.modelId)?.conversationModel !==
+                false) {
             const configuredModelId = conversation.modelId;
             const selected = selectModel(version, availableModels, conversation.modelId);
             if (selected.id !== conversation.modelId)
@@ -1707,10 +1709,12 @@ function allowedModels(version, models) {
     return models.filter((model) => model.enabled && allowed.has(model.modelId));
 }
 function selectModel(version, models, requestedModelId) {
-    const available = allowedModels(version, models);
+    const available = allowedModels(version, models).filter((model) => model.conversationModel !== false);
     const requested = available.find((candidate) => candidate.id === requestedModelId);
     if (requested !== undefined)
         return requested;
+    if (models.some((candidate) => candidate.id === requestedModelId && candidate.conversationModel === false))
+        throw new Error('HOSTED_CONVERSATION_MODEL_NOT_AVAILABLE');
     const defaultModel = available.find((candidate) => candidate.modelId === version.modelPolicy.defaultId);
     if (defaultModel !== undefined)
         return defaultModel;

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

@@ -1,6 +1,7 @@
 import { modelUsageGrantSchema, modelUsageGrantClaimsSchema, modelUsageRecordSchema } from '@myagentroam/protocol';
 import { nodeLog } from '../operational.js';
 import { AsyncLocalStorage } from 'node:async_hooks';
+import { normalizeMarAgentUsage } from '../runner/mar-agent/conversation-normalizer.js';
 /** Execution-private attribution never enters Run projections or browser Watch events. */
 export class NodeModelUsageService {
     outbox;
@@ -27,7 +28,13 @@ export class NodeModelUsageService {
             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 });
+            this.bindings.set(runId, {
+                userId: claims.userId,
+                grant: parsedGrant,
+                scopeId: claims.scopeId,
+                sessionId,
+                runner
+            });
         }
         catch {
             nodeLog('model.usage.invalid', { code: 'USAGE_GRANT_INVALID' });
@@ -36,6 +43,27 @@ export class NodeModelUsageService {
     release(runId) {
         this.bindings.delete(runId);
     }
+    completion(executionId, grant, sessionId, expectedUserId) {
+        this.bind(executionId, grant, sessionId, 'mar-agent');
+        if (expectedUserId !== undefined && this.bindings.get(executionId)?.userId !== expectedUserId)
+            this.release(executionId);
+        if (!this.bindings.has(executionId))
+            throw new Error('PROMPT_COMPLETION_USAGE_GRANT_REQUIRED');
+        return {
+            onModelUsage: (usage) => this.record(executionId, {
+                ...normalizeMarAgentUsage({
+                    ...usage,
+                    sessionId,
+                    executionId,
+                    purpose: 'other',
+                    agentRole: 'root'
+                }),
+                purpose: 'prompt_completion'
+            }),
+            onModelUsageFailure: () => nodeLog('model.usage.invalid', { code: 'PROMPT_COMPLETION_USAGE_FAILED' }),
+            release: () => this.release(executionId)
+        };
+    }
     promoteSession(previousId, nextId) {
         for (const [runId, binding] of this.bindings)
             if (binding.sessionId === previousId)

package/dist/service/native-session-watch-service.js

@@ -199,6 +199,16 @@ export class NativeSessionWatchService {
     has(sessionId) {
         return this.watches.has(sessionId);
     }
+    observes(sessionHash, connectionId, workspaceId, sessionId) {
+        const ownerKey = `${sessionHash}:${connectionId}`;
+        const lease = this.leases.get(ownerKey);
+        return (lease !== undefined &&
+            lease.ready &&
+            lease.expiresAt > Date.now() &&
+            lease.sessionId === sessionId &&
+            lease.workspaceId === workspaceId &&
+            this.sessionWatchSlots.owns(ownerKey, lease.slotToken));
+    }
     isWatching(sessionId) {
         return this.has(sessionId);
     }

package/dist/service/prompt-completion-attention.js

@@ -0,0 +1,66 @@
+import { isAbsolute, win32 } from 'node:path';
+/** Browser observations are hints, not authority to read paths or execute instructions. */
+export async function projectPredictionAttention(events, read, signal, now = Date.now()) {
+    const result = [];
+    let remaining = 4096;
+    for (const event of events.slice(-20).reverse()) {
+        signal.throwIfAborted();
+        if (event.observedAt > now ||
+            now - event.observedAt >= 180_000 ||
+            isAbsolute(event.path) ||
+            win32.isAbsolute(event.path) ||
+            event.path.split(/[\\/]/u).includes('..') ||
+            event.path.includes('\0') ||
+            event.path.startsWith('mar-attachment:'))
+            continue;
+        const metadata = {
+            kind: event.kind,
+            path: event.path,
+            worktreePath: event.worktreePath,
+            source: event.source,
+            observedAt: event.observedAt
+        };
+        // Diff blocks without a verified content identity are metadata-only, never read in full.
+        if (event.kind === 'DIFF' || !event.revision || event.startLine === undefined) {
+            result.push(metadata);
+            if (result.length >= 8)
+                break;
+            continue;
+        }
+        try {
+            const value = (await read(event));
+            signal.throwIfAborted();
+            if (value.revision !== event.revision ||
+                value.encoding !== 'utf-8' ||
+                typeof value.content !== 'string')
+                continue;
+            const lines = value.content.split('\n');
+            // A bounded prefix can end mid-line. Never present that tail as a verified full line.
+            if (value.truncated)
+                lines.pop();
+            const endLine = Math.min(event.endLine, event.startLine + 79, lines.length);
+            if (event.startLine > endLine)
+                continue;
+            const text = lines
+                .slice(event.startLine - 1, endLine)
+                .join('\n')
+                .slice(0, Math.min(2048, remaining));
+            remaining -= text.length;
+            result.push({
+                ...metadata,
+                revision: value.revision,
+                startLine: event.startLine,
+                endLine,
+                text
+            });
+        }
+        catch (error) {
+            if (signal.aborted)
+                throw error;
+            // Missing, moved, changed, binary or inaccessible optional references are omitted.
+        }
+        if (result.length >= 8 || remaining <= 0)
+            break;
+    }
+    return JSON.stringify(result);
+}