@myagentroam/node 0.11.35 → 0.11.37

package/dist/session/runtime/conversation-projection.js

@@ -0,0 +1,310 @@
+import { permissionStopSchema } from '@myagentroam/protocol';
+import { projectConversationWorkProcesses } from './work-process.js';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null;
+}
+export function runConversationItemId(runId, itemId, kind) {
+    return kind === 'user_message' ? itemId : `${runId}:${itemId}`;
+}
+export function projectConversationEvent(turn, run, event, runTerminal) {
+    let needsProcessProjection = false;
+    const update = (turn) => {
+        if (event.eventType === 'text.delta' &&
+            isRecord(event.payload) &&
+            typeof event.payload.text === 'string') {
+            const nativeItemId = typeof event.payload.itemId === 'string' && event.payload.itemId.length <= 88
+                ? event.payload.itemId
+                : undefined;
+            const stableItemId = nativeItemId === undefined ? undefined : `${event.runId}:${nativeItemId}`;
+            const lastItem = turn.items.at(-1);
+            const existing = stableItemId === undefined
+                ? lastItem?.kind === 'assistant_message' && activeConversationItem(lastItem.status)
+                    ? lastItem
+                    : undefined
+                : turn.items.find((item) => item.id === stableItemId && item.kind === 'assistant_message');
+            const text = `${existing === undefined ? '' : readableText(existing.payload)}${event.payload.text}`;
+            const sourceItemId = conversationSourceItemId(event.payload) ?? existing?.sourceItemId;
+            needsProcessProjection =
+                existing === undefined ||
+                    existing.sourceItemId !== sourceItemId ||
+                    (!readableText(existing.payload).trim() && !!text.trim());
+            const item = {
+                id: existing?.id ?? stableItemId ?? `${event.runId}:assistant:${event.sequence}`,
+                ...(sourceItemId === undefined ? {} : { sourceItemId }),
+                sessionId: run.sessionId,
+                turnId: turn.id,
+                runId: event.runId,
+                parentItemId: null,
+                sourceSequence: existing?.sourceSequence ?? event.sequence,
+                revision: event.sequence,
+                kind: 'assistant_message',
+                ...(existing?.processGroup === undefined ? {} : { processGroup: existing.processGroup }),
+                updatedAt: event.createdAt,
+                status: 'IN_PROGRESS',
+                payload: { text, format: 'markdown', model: null },
+                startedAt: existing?.startedAt ?? event.createdAt,
+                completedAt: null
+            };
+            return {
+                ...turn,
+                status: 'RUNNING',
+                startedAt: turn.startedAt ?? event.createdAt,
+                items: existing === undefined
+                    ? [...turn.items, item]
+                    : turn.items.map((value) => (value.id === item.id ? item : value))
+            };
+        }
+        const projected = conversationItemFromEvent(event);
+        if (projected !== undefined) {
+            const itemId = runConversationItemId(event.runId, projected.itemId, projected.kind);
+            const trailingItem = turn.items.at(-1);
+            const orderedItems = projected.kind !== 'user_message' &&
+                trailingItem?.kind === 'assistant_message' &&
+                activeConversationItem(trailingItem.status)
+                ? turn.items.map((item) => item.id === trailingItem.id
+                    ? {
+                        ...item,
+                        status: 'COMPLETED',
+                        completedAt: event.createdAt,
+                        updatedAt: event.createdAt
+                    }
+                    : item)
+                : turn.items;
+            const existing = orderedItems.find((item) => item.id === itemId) ??
+                (projected.kind === 'assistant_message' &&
+                    projected.itemId.startsWith('codex:') &&
+                    trailingItem?.kind === 'assistant_message' &&
+                    trailingItem.id.startsWith(`${event.runId}:assistant:`) &&
+                    activeConversationItem(trailingItem.status)
+                    ? trailingItem
+                    : undefined);
+            const status = projected.status;
+            const sourceItemId = projected.sourceItemId ?? existing?.sourceItemId;
+            const parentItemId = projected.parentItemId === undefined
+                ? (existing?.parentItemId ?? null)
+                : runConversationItemId(event.runId, projected.parentItemId);
+            needsProcessProjection =
+                existing === undefined ||
+                    existing.kind !== projected.kind ||
+                    projected.kind === 'context_compaction' ||
+                    existing.parentItemId !== parentItemId ||
+                    existing.sourceItemId !== sourceItemId ||
+                    (projected.kind === 'assistant_message' &&
+                        !!readableText(existing.payload).trim() !== !!readableText(projected.payload).trim()) ||
+                    (projected.kind === 'reasoning' && existing.processGroup === undefined);
+            const item = {
+                id: itemId,
+                sessionId: run.sessionId,
+                turnId: turn.id,
+                runId: event.runId,
+                parentItemId,
+                ...(sourceItemId === undefined ? {} : { sourceItemId }),
+                sourceSequence: existing?.sourceSequence ?? event.sequence,
+                revision: (existing?.revision ?? -1) + 1,
+                kind: projected.kind,
+                ...(existing?.processGroup === undefined ? {} : { processGroup: existing.processGroup }),
+                updatedAt: event.createdAt,
+                status,
+                payload: mergeConversationItemPayload(existing?.payload, projected),
+                ...(projected.permissionStop === undefined
+                    ? {}
+                    : { permissionStop: projected.permissionStop }),
+                startedAt: existing?.startedAt ?? event.createdAt,
+                completedAt: completedConversationItem(status) ? event.createdAt : null
+            };
+            return {
+                ...turn,
+                status: runTerminal ? run.status : 'RUNNING',
+                startedAt: turn.startedAt ?? event.createdAt,
+                items: existing === undefined
+                    ? [...orderedItems, item]
+                    : orderedItems.map((value) => (value.id === existing.id ? item : value))
+            };
+        }
+        if (event.eventType === 'run.started' || event.eventType === 'run.running')
+            return { ...turn, status: 'RUNNING', startedAt: turn.startedAt ?? event.createdAt };
+        if (event.eventType === 'run.completed' ||
+            event.eventType === 'run.failed' ||
+            event.eventType === 'run.rejected') {
+            const status = event.status ?? run.status;
+            return {
+                ...turn,
+                status,
+                completedAt: event.createdAt,
+                items: turn.items.map((item) => activeConversationItem(item.status)
+                    ? {
+                        ...item,
+                        status: completedStatusForRun(status),
+                        completedAt: event.createdAt
+                    }
+                    : item)
+            };
+        }
+        return turn;
+    };
+    const next = update(turn);
+    // Ordinary token/output updates retain membership; only structural input needs a scan.
+    return needsProcessProjection ? projectConversationWorkProcesses(next) : next;
+}
+function readableText(value) {
+    return isRecord(value) && typeof value.text === 'string' ? value.text : '';
+}
+export function conversationItemFromEvent(event) {
+    if (isRecord(event.payload)) {
+        const approvalId = event.payload.approvalId;
+        if (typeof approvalId === 'string' && approvalId.length > 0) {
+            if (event.eventType === 'approval.request')
+                return {
+                    itemId: `approval:${approvalId}`,
+                    kind: 'approval_request',
+                    status: 'PENDING',
+                    payload: {
+                        approvalId,
+                        approvalStatus: 'PENDING',
+                        approval: event.payload.payload,
+                        expiresAt: event.payload.expiresAt
+                    },
+                    merge: false
+                };
+            if (event.eventType === 'approval.decided') {
+                const decision = event.payload.decision;
+                if (decision === 'APPROVED' || decision === 'REJECTED')
+                    return {
+                        itemId: `approval:${approvalId}`,
+                        kind: 'approval_request',
+                        status: decision === 'APPROVED' ? 'COMPLETED' : 'DECLINED',
+                        payload: { approvalId, approvalStatus: decision },
+                        merge: true
+                    };
+            }
+            if (event.eventType === 'approval.expired')
+                return {
+                    itemId: `approval:${approvalId}`,
+                    kind: 'approval_request',
+                    status: 'CANCELLED',
+                    payload: { approvalId, approvalStatus: 'EXPIRED' },
+                    merge: true
+                };
+        }
+    }
+    if (event.eventType !== 'conversation.item' || !isRecord(event.payload))
+        return undefined;
+    const itemId = event.payload.itemId;
+    const kind = event.payload.kind;
+    const status = event.payload.status;
+    const payload = event.payload.payload;
+    if (typeof itemId !== 'string' ||
+        itemId.length === 0 ||
+        itemId.length > 88 ||
+        typeof kind !== 'string' ||
+        !projectableConversationKind(kind) ||
+        typeof status !== 'string' ||
+        !projectableConversationStatus(status) ||
+        !isRecord(payload))
+        return undefined;
+    const append = event.payload.append;
+    const sourceItemId = conversationSourceItemId(event.payload);
+    const permissionStop = permissionStopSchema.safeParse(event.payload.permissionStop);
+    return {
+        itemId,
+        kind,
+        status,
+        payload,
+        ...(sourceItemId === undefined ? {} : { sourceItemId }),
+        ...(typeof event.payload.parentItemId === 'string' &&
+            event.payload.parentItemId.length > 0 &&
+            event.payload.parentItemId.length <= 88
+            ? { parentItemId: event.payload.parentItemId }
+            : {}),
+        ...(permissionStop.success ? { permissionStop: permissionStop.data } : {}),
+        merge: event.payload.merge === true,
+        ...(append === 'sections' || append === 'outputPreview' || append === 'outputSummary'
+            ? { append }
+            : {})
+    };
+}
+function conversationSourceItemId(payload) {
+    return typeof payload.sourceItemId === 'string' &&
+        payload.sourceItemId.length > 0 &&
+        payload.sourceItemId.length <= 1024
+        ? payload.sourceItemId
+        : undefined;
+}
+function projectableConversationKind(value) {
+    return (value === 'user_message' ||
+        value === 'assistant_message' ||
+        value === 'reasoning' ||
+        value === 'tool_call' ||
+        value === 'command_execution' ||
+        value === 'approval_request' ||
+        value === 'user_input_request' ||
+        value === 'plan' ||
+        value === 'todo_list' ||
+        value === 'file_change' ||
+        value === 'context_compaction' ||
+        value === 'unknown' ||
+        value === 'warning' ||
+        value === 'error');
+}
+function projectableConversationStatus(value) {
+    return [
+        'PENDING',
+        'IN_PROGRESS',
+        'COMPLETED',
+        'FAILED',
+        'DECLINED',
+        'CANCELLED',
+        'INTERRUPTED'
+    ].includes(value);
+}
+function mergeConversationItemPayload(existing, next) {
+    const base = next.merge && isRecord(existing) ? existing : {};
+    const value = { ...base, ...next.payload };
+    if (next.append === 'sections') {
+        const prior = Array.isArray(base.sections) ? base.sections : [];
+        const incoming = Array.isArray(next.payload.sections) ? next.payload.sections : [];
+        const sections = new Map();
+        for (const section of [...prior, ...incoming]) {
+            if (!isRecord(section) ||
+                typeof section.index !== 'number' ||
+                !Number.isInteger(section.index) ||
+                section.index < 0 ||
+                typeof section.text !== 'string')
+                continue;
+            sections.set(section.index, appendProjectionText(sections.get(section.index) ?? '', section.text));
+        }
+        value.sections = [...sections]
+            .sort(([left], [right]) => left - right)
+            .map(([index, text]) => ({ index, text }));
+    }
+    if (next.append === 'outputPreview') {
+        const prior = typeof base.outputPreview === 'string' ? base.outputPreview : '';
+        const incoming = typeof next.payload.outputPreview === 'string' ? next.payload.outputPreview : '';
+        value.outputPreview = appendProjectionText(prior, incoming);
+    }
+    if (next.append === 'outputSummary') {
+        const prior = typeof base.outputSummary === 'string' ? base.outputSummary : '';
+        const incoming = typeof next.payload.outputSummary === 'string' ? next.payload.outputSummary : '';
+        value.outputSummary = appendProjectionText(prior, incoming);
+    }
+    return value;
+}
+function appendProjectionText(previous, next) {
+    const text = `${previous}${next}`;
+    return text.length <= 10_000 ? text : `${text.slice(0, 9_999)}…`;
+}
+export function activeConversationItem(status) {
+    return status === 'PENDING' || status === 'IN_PROGRESS';
+}
+function completedConversationItem(status) {
+    return !activeConversationItem(status);
+}
+export function completedStatusForRun(status) {
+    if (status === 'INTERRUPTED')
+        return 'INTERRUPTED';
+    if (status === 'CANCELLED')
+        return 'CANCELLED';
+    if (status === 'FAILED')
+        return 'FAILED';
+    return 'COMPLETED';
+}

package/dist/session/runtime/type-guards.js

@@ -0,0 +1,19 @@
+import { isPlainRecord } from '../../util/records.js';
+export function isTerminalRunStatus(status) {
+    return (status === 'SUCCEEDED' ||
+        status === 'FAILED' ||
+        status === 'CANCELLED' ||
+        status === 'INTERRUPTED');
+}
+export function isNodeAgentRun(value) {
+    return (isPlainRecord(value) &&
+        typeof value.id === 'string' &&
+        typeof value.sessionId === 'string' &&
+        typeof value.status === 'string');
+}
+export function isNodeConversationTurn(value) {
+    return (isPlainRecord(value) &&
+        typeof value.id === 'string' &&
+        typeof value.sessionId === 'string' &&
+        Array.isArray(value.items));
+}

package/dist/{service → session}/session-catalog-service.js

@@ -1,11 +1,12 @@
-import { resolveSessionRollbackTarget } from './session-rollback-target.js';
+import { resolveSessionRollbackTarget } from '../service/session-rollback-target.js';
 import { sessionGroup } from './session-presentation-service.js';
 import { removeNativeSession } from '../native-session-history.js';
 import { nodeLog } from '../operational.js';
-import { isTerminalRunStatus, sessionPage } from '../util/node-operation-parsers.js';
+import { isTerminalRunStatus } from './runtime/type-guards.js';
+import { sessionPage } from './pagination.js';
 import { latestSessionActivityAt } from './session-presentation-service.js';
-import { marctlSessionSummary } from './session-recent-activity.js';
-import { WorkspaceSessionCleanupBudget, WorkspaceSessionCleanupDeadline } from './workspace-session-cleanup-budget.js';
+import { marctlSessionSummary } from '../service/session-recent-activity.js';
+import { WorkspaceSessionCleanupBudget, WorkspaceSessionCleanupDeadline } from '../service/workspace-session-cleanup-budget.js';
 export class SessionCatalogService {
     options;
     rewindQueue = Promise.resolve();

package/dist/{service → session}/session-command-service.js

@@ -1,8 +1,8 @@
 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';
-import { personalInstructionsForRunner } from '../util/personal-instructions.js';
+import { isPlainRecord } from '../util/records.js';
+import { parseSecretEnvironment } from '../mcp/secret-environment.js';
+import { personalInstructionsForRunner } from '../runner/personal-instructions.js';
 export class SessionCommandService {
     options;
     constructor(options) {

package/dist/{service → session}/session-identity-service.js

@@ -1,5 +1,5 @@
 import { nodeLog } from '../operational.js';
-import { isTerminalRunStatus } from '../util/node-operation-parsers.js';
+import { isTerminalRunStatus } from './runtime/type-guards.js';
 import { safeErrorCode } from '../util/safe-error.js';
 export class SessionIdentityService {
     options;

package/dist/{service → session}/session-lifecycle-service.js

@@ -1,10 +1,11 @@
 import { RUNNER_EXECUTION_CONTEXT } from '../runner/execution-context.js';
-import { parseMessageAttachments, validSessionEffort, validSessionOption, validSessionTitle } from '../util/node-operation-parsers.js';
-import { isPlainRecord } from '../util/node-operation-parsers.js';
-import { parseSecretEnvironment } from '../util/secret-environment.js';
-import { ScheduledSessionStore } from './scheduled-session-store.js';
-import { normalizeSessionPrompt } from '../util/personal-instructions.js';
-import { resolveWorkspaceExecutionDirectory } from '../workspace.js';
+import { validSessionEffort, validSessionOption, validSessionTitle } from './input-validation.js';
+import { parseMessageAttachments } from './attachments.js';
+import { isPlainRecord } from '../util/records.js';
+import { parseSecretEnvironment } from '../mcp/secret-environment.js';
+import { ScheduledSessionStore } from '../service/scheduled-session-store.js';
+import { normalizeSessionPrompt } from '../runner/personal-instructions.js';
+import { resolveWorkspaceExecutionDirectory } from '../workspace/path-access.js';
 export class SessionLifecycleService {
     options;
     starts = new Map();
@@ -109,7 +110,17 @@ export class SessionLifecycleService {
         if (typeof input.sessionId !== 'string' ||
             (input.direction !== 'up' && input.direction !== 'down'))
             throw new Error('SESSION_PIN_MOVE_INVALID');
-        const workspaceId = this.options.database().movePinnedSession(input.sessionId, input.direction);
+        let target;
+        if (input.targetSessionId !== undefined || input.position !== undefined) {
+            if (typeof input.targetSessionId !== 'string' ||
+                input.targetSessionId.length === 0 ||
+                (input.position !== 'before' && input.position !== 'after'))
+                throw new Error('SESSION_PIN_MOVE_INVALID');
+            target = { sessionId: input.targetSessionId, position: input.position };
+        }
+        const workspaceId = this.options
+            .database()
+            .movePinnedSession(input.sessionId, input.direction, target);
         this.options.invalidateWorkspaceSessions(workspaceId);
         return { moved: true };
     }

package/dist/{service → session}/session-message-service.js

@@ -1,14 +1,15 @@
 import { RUNNER_EXECUTION_CONTEXT } from '../runner/execution-context.js';
 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';
-import { personalInstructionsForRunner } from '../util/personal-instructions.js';
+import { sessionTitleFromFirstMessage } from './input-validation.js';
+import { isImageAttachment, isRunnerImageAttachment, parseComposerAttachmentIds, parseMessageAttachments, withNonImageAttachmentPrompt } from './attachments.js';
+import { parseSecretEnvironment } from '../mcp/secret-environment.js';
+import { personalInstructionsForRunner } from '../runner/personal-instructions.js';
 import { safeErrorCode } from '../util/safe-error.js';
-import { publicGoalStartText } from './goal-runtime.js';
+import { publicGoalStartText } from '../service/goal-runtime.js';
 import { serializeComposerTag, composerVisibleText, steerComposerMessage } from '@myagentroam/protocol';
 import { relative } from 'node:path';
-import { prepareComposerResourceInput, composerResourceInputTags, withSessionMessageOrigin, validateComposerSkills } from './composer-message-input.js';
+import { prepareComposerResourceInput, composerResourceInputTags, withSessionMessageOrigin, validateComposerSkills } from '../service/composer-message-input.js';
 const INTERNAL_GOAL = Symbol('internalGoal');
 const INTERNAL_SCHEDULE = Symbol('internalSchedule');
 const INTERNAL_RESTORE = Symbol('internalRestore');

package/dist/{service → session}/session-presentation-service.js

@@ -1,4 +1,4 @@
-import { ScheduledSessionStore } from './scheduled-session-store.js';
+import { ScheduledSessionStore } from '../service/scheduled-session-store.js';
 export class SessionPresentationService {
     options;
     constructor(options) {

package/dist/{service → session}/session-query-service.js

@@ -1,5 +1,5 @@
-import { marctlSessionDetail } from './session-recent-activity.js';
-import { isPlainRecord } from '../util/node-operation-parsers.js';
+import { marctlSessionDetail } from '../service/session-recent-activity.js';
+import { isPlainRecord } from '../util/records.js';
 import { toolResultResourceInputSchema, toolResultResourcePageSchema } from '@myagentroam/protocol';
 export class SessionQueryService {
     options;

package/dist/{service → session}/session-schedule-service.js

@@ -1,5 +1,5 @@
-import { assertScheduleTimezone, parseScheduledCron } from './scheduled-session-recurrence.js';
-import { ScheduledSessionStore } from './scheduled-session-store.js';
+import { assertScheduleTimezone, parseScheduledCron } from '../service/scheduled-session-recurrence.js';
+import { ScheduledSessionStore } from '../service/scheduled-session-store.js';
 export class SessionScheduleService {
     options;
     constructor(options) {

package/dist/util/records.js

@@ -0,0 +1,3 @@
+export function isPlainRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}

package/dist/workspace/contracts.js

@@ -0,0 +1 @@
+export {};