@myagentroam/agent 0.10.59 → 0.10.61

package/dist/agent-core/runtime/compaction/history.d.ts

@@ -1,5 +1,5 @@
 import type { ModelMessage } from '../../model/contracts.js';
-import type { CompactHistoryMessage, CompactUserInput } from '../../session/jsonl-store.js';
+import type { CompactHistoryMessage, CompactUserInput } from '../../session/store/index.js';
 export declare const DEFAULT_COMPACTION_FOCUS = "Create a durable continuation state for the next model invocation.";
 export declare function buildNativeCompactionMessages(messages: readonly ModelMessage[], input?: {
     focus?: string;

package/dist/agent-core/runtime/compaction/retained-context.d.ts

@@ -1,6 +1,6 @@
 import type { ModelMessage } from '../../model/contracts.js';
 import type { CompactSnapshotAnchor } from '../events.js';
 /** Use a public native identity, never private context text, as the visible boundary. */
-export declare function compactSnapshotAnchor(messages: readonly ModelMessage[], sources: WeakMap<ModelMessage, import('../../session/jsonl-store.js').SessionRecord>): CompactSnapshotAnchor | undefined;
+export declare function compactSnapshotAnchor(messages: readonly ModelMessage[], sources: WeakMap<ModelMessage, import('../../session/store/index.js').SessionRecord>): CompactSnapshotAnchor | undefined;
 /** Decode the SDK-owned checkpoint suffix without promoting contextual text to real input. */
 export declare function restoreCompactTail(value: unknown): ModelMessage | undefined;

package/dist/agent-core/runtime/compaction/retained-context.js

@@ -1,4 +1,4 @@
-import { parseModelInputMetadata } from '../../session/jsonl-store.js';
+import { parseModelInputMetadata } from '../../session/store/index.js';
 import { restoreModelContext } from '../context/projection.js';
 /** Use a public native identity, never private context text, as the visible boundary. */
 export function compactSnapshotAnchor(messages, sources) {

package/dist/agent-core/runtime/compaction/smart.d.ts

@@ -1,5 +1,5 @@
 import type { ModelMessage } from '../../model/contracts.js';
-import { type SessionRecord } from '../../session/jsonl-store.js';
+import { type SessionRecord } from '../../session/store/index.js';
 export declare const SMART_COMPACTION_MARKER = "<mar_runtime>\n  <smart_compaction>For this message only, smart_compact may be considered at a clear transition into sustained new work, when the previous phase is largely complete and its details have low continuation value.</smart_compaction>\n</mar_runtime>";
 export interface SmartCompactionInput {
     readonly recordId: string;

package/dist/agent-core/runtime/compaction/smart.js

@@ -1,5 +1,5 @@
 import { MarAgentError } from '../../error.js';
-import { compactSummaryFromCheckpoint } from '../../session/jsonl-store.js';
+import { compactSummaryFromCheckpoint } from '../../session/store/index.js';
 export const SMART_COMPACTION_MARKER = '<mar_runtime>\n  <smart_compaction>For this message only, smart_compact may be considered at a clear transition into sustained new work, when the previous phase is largely complete and its details have low continuation value.</smart_compaction>\n</mar_runtime>';
 /** A measured watermark, not the stricter native-request budget calibration. */
 export function latestSmartContextTokens(records, modelId, contextWindowTokens) {

package/dist/agent-core/runtime/context/gc-runtime.d.ts

@@ -1,6 +1,6 @@
 import type { ClientToolDefinition, ModelUsage } from '../../model/contracts.js';
 import { type ContextGcPlatform } from '../../session/context-gc-checkpoint.js';
-import { JsonlSessionStore, type SessionRecord } from '../../session/jsonl-store.js';
+import { JsonlSessionStore, type SessionRecord } from '../../session/store/index.js';
 import { type ContextProjection } from './projection.js';
 export interface ContextGcRuntimeInput {
     readonly store: JsonlSessionStore;

package/dist/agent-core/runtime/context/gc-runtime.js

@@ -1,5 +1,5 @@
 import { isDeepStrictEqual } from 'node:util';
-import { ContextGcCheckpointCache, contextGcMinimumUsageGrowth, contextGcReplacementKey, contextGcSourceProjectionHash } from '../../session/context-gc-checkpoint.js';
+import { ContextGcCheckpointCache, contextGcMinimumUsageGrowth, contextGcReplacementKey } from '../../session/context-gc-checkpoint.js';
 import { CONTEXT_GC_POLICY, contextGcEligibleUsage, inspectContextGc } from './gc.js';
 import { buildContextProjection } from './projection.js';
 /** Only scheduling metadata survives a call; records and validation caches do not. */
@@ -95,8 +95,10 @@ async function attemptContextGc(input) {
         return { result: false };
     let deferred = { result: false };
     let draft;
+    let records;
     try {
-        const records = input.records ?? (await input.store.readExecutionState(input.sessionId)).contextRecords;
+        records =
+            input.records ?? (await input.store.readExecutionState(input.sessionId)).contextRecords;
         const checkpointCache = new ContextGcCheckpointCache();
         const previous = checkpointCache.read(records, undefined, input.workspace);
         if (previous) {
@@ -148,27 +150,23 @@ async function attemptContextGc(input) {
         const plan = inspection.plan;
         if (!plan)
             return deferred;
-        const hash = contextGcSourceProjectionHash(records, plan.draft.boundarySequence, plan.draft.base);
-        if (!hash)
-            return deferred;
-        plan.draft.sourceProjectionHash = hash;
         draft = plan.draft;
     }
     catch {
         return deferred;
     }
     try {
-        await input.store.commitContextGc(input.sessionId, draft);
+        const committed = await input.store.commitContextGc(input.sessionId, draft, records);
         return {
             ...deferred,
-            result: await matchingCheckpointWasPersisted(input.store, input.sessionId, draft, input.workspace)
+            result: await matchingCheckpointWasPersisted(input.store, input.sessionId, draft, input.workspace, records, committed)
         };
     }
     catch (commitError) {
         try {
             return {
                 ...deferred,
-                result: await matchingCheckpointWasPersisted(input.store, input.sessionId, draft, input.workspace)
+                result: await matchingCheckpointWasPersisted(input.store, input.sessionId, draft, input.workspace, records)
             };
         }
         catch {
@@ -178,13 +176,21 @@ async function attemptContextGc(input) {
         return deferred;
     }
 }
-async function matchingCheckpointWasPersisted(store, sessionId, draft, workspace) {
-    const state = await store.readExecutionState(sessionId);
-    const projection = buildContextProjection(state.contextRecords, workspace);
+async function matchingCheckpointWasPersisted(store, sessionId, draft, workspace, records, committed) {
+    const record = committed ??
+        (await store.readPage(sessionId, {
+            limit: 1,
+            beforeSequence: draft.boundarySequence + 2
+        })).records[0];
+    if (record?.sequence !== draft.boundarySequence + 1 || record.type !== 'context.gc.completed')
+        return false;
+    const updatedRecords = [...records, record];
+    const projection = buildContextProjection(updatedRecords, workspace);
+    if (committed)
+        return { records: updatedRecords, projection };
     const payload = projection.checkpoint;
     const latest = payload ? { payload } : undefined;
     if (latest?.payload.boundarySequence !== draft.boundarySequence ||
-        latest.payload.sourceProjectionHash !== draft.sourceProjectionHash ||
         !isDeepStrictEqual(latest.payload.base, draft.base) ||
         !isDeepStrictEqual(latest.payload.trigger, draft.trigger) ||
         !isDeepStrictEqual(latest.payload.economics, draft.economics) ||
@@ -198,7 +204,7 @@ async function matchingCheckpointWasPersisted(store, sessionId, draft, workspace
         const value = persisted.get(contextGcReplacementKey(replacement));
         return value !== undefined && isDeepStrictEqual(value, replacement);
     });
-    return matches ? { records: state.contextRecords, projection } : false;
+    return matches ? { records: updatedRecords, projection } : false;
 }
 function isRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);

package/dist/agent-core/runtime/context/gc.d.ts

@@ -1,6 +1,6 @@
 import type { ClientToolDefinition, ModelMessage, ModelUsage } from '../../model/contracts.js';
 import { ContextGcCheckpointCache, type ContextGcCheckpointDraft, type ContextGcEconomicsPolicy, type ContextGcMetrics, type ContextGcPlatform, type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
-import type { SessionRecord } from '../../session/jsonl-store.js';
+import type { SessionRecord } from '../../session/store/index.js';
 export declare const CONTEXT_GC_POLICY: ContextGcEconomicsPolicy;
 interface ContextGcEconomicsInput {
     readonly contextUsageTokens: number;

package/dist/agent-core/runtime/context/gc.js

@@ -1,5 +1,5 @@
 import { codeCallEvidence, codePartialPatchCallEvidence, codeObservationEvidence, retainedCodeInputs } from '../../session/context-gc-observations.js';
-import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcLogicalPathKey, contextGcMinimumUsageGrowth, contextGcRecordSourceHash, contextGcTargetKey, normalizeContextGcReplacements } from '../../session/context-gc-checkpoint.js';
+import { ContextGcCheckpointCache, contextGcBaseFromRecords, contextGcLogicalPathKey, contextGcMinimumUsageGrowth, contextGcTargetKey, normalizeContextGcReplacements } from '../../session/context-gc-checkpoint.js';
 import { codeCellCompletionSequence, contextGcApplyPatchInputReplacement, contextGcCodeModeInputReplacement, contextGcCodeModeOutputReplacement, contextGcExecInputReplacement, contextGcExecOutputReplacement, contextGcPatchResultFromCompletedPayload, contextGcPatchResultFromFailedPayload, contextGcStaleReadReplacement, contextGcWebOutputReplacement, normalizeContextGcCodeModeInput, normalizeContextGcExecResult } from '../../session/context-gc-replacements.js';
 import { contextGcSubagentNeedsRetainedPriorFinal, contextGcSubagentOutputReplacement, contextGcSubagentPriorFinalIsRetained, contextGcSubagentSnapshotIsPreciselyCovered, contextGcSubagentSnapshotIsSuperseded, contextGcSubagentSnapshotTurnId, normalizeContextGcSubagentSnapshot } from '../../session/context-gc-subagent.js';
 import { parseReadContextOutput } from '../../tools/local/read-context.js';
@@ -425,7 +425,6 @@ function finalizePlan(input, evaluated) {
         version: 1,
         base,
         boundarySequence: evaluated.boundarySequence,
-        sourceProjectionHash: '',
         replacements,
         trigger: {
             usageSequence: evaluated.usageRecord.sequence,
@@ -558,7 +557,7 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
                 toolName: 'apply_patch',
                 callId: patch.callId,
                 target: patchTarget,
-                replacementArguments: contextGcApplyPatchInputReplacement(patchCall.message.arguments, result, evidenceSequence),
+                replacementArguments: contextGcApplyPatchInputReplacement(patchCall.message.arguments, result),
                 providerAliasTargets: patch.aliases
                     .map(({ record, message }) => targetFor(record, message))
                     .filter((target) => target !== undefined),
@@ -589,8 +588,6 @@ function collectStageACandidates(input, groups, existingReplacements, existingTa
                         replacement: contextGcStaleReadReplacement({
                             path: item.path,
                             content: item.content,
-                            evidenceSequence,
-                            supersededByCallId: patch.callId,
                             operation: matched.operation
                         }),
                         evidenceSequence,
@@ -693,9 +690,7 @@ function collectSubagentCandidates(input, groups, existingTargets, candidateSavi
             replacementContent: contextGcSubagentOutputReplacement({
                 sourceContent,
                 source: source.snapshot,
-                terminal: terminal.snapshot,
-                terminalCallId: terminal.group.callId,
-                evidenceSequence
+                terminal: terminal.snapshot
             }),
             terminalToolName: terminal.group.toolName,
             terminalCallId: terminal.group.callId,
@@ -819,7 +814,7 @@ function collectExecCandidates(input, groups, existingTargets, candidateSavings)
                     toolName: invocation.group.toolName,
                     callId: invocation.group.callId,
                     target: callTarget,
-                    replacementArguments: contextGcExecInputReplacement(invocation.input, 3, invocation.group.toolName),
+                    replacementArguments: contextGcExecInputReplacement(invocation.input, invocation.group.toolName),
                     providerAliasTargets: invocation.group.aliases
                         .map(({ record, message }) => targetFor(record, message))
                         .filter((target) => target !== undefined),
@@ -1274,7 +1269,6 @@ function targetFor(record, message) {
         role: message.role,
         ...(callId === undefined ? {} : { callId }),
         ...(toolName === undefined ? {} : { toolName }),
-        sourceHash: contextGcRecordSourceHash(record),
         ...(message.observationId ? { observationId: message.observationId } : {})
     };
 }

package/dist/agent-core/runtime/context/projection.d.ts

@@ -1,6 +1,6 @@
 import type { ModelMessage } from '../../model/contracts.js';
 import { type ContextGcCheckpointCache, type ContextGcCheckpointPayload, type ContextGcReplacement } from '../../session/context-gc-checkpoint.js';
-import type { SessionRecord } from '../../session/jsonl-store.js';
+import type { SessionRecord } from '../../session/store/index.js';
 export interface ContextProjectionEntry {
     readonly record: SessionRecord;
     readonly message: ModelMessage;

package/dist/agent-core/runtime/context/projection.js

@@ -1,7 +1,7 @@
 import { anthropicThinkingBlock } from '../../model/anthropic-thinking.js';
 import { appliedInputRecord } from '../../session/deferred-input.js';
-import { inputMetadataFromRecord } from '../../session/jsonl-store.js';
-import { contextGcRecordSourceHash, contextGcTargetKey, latestValidContextGcCheckpoint } from '../../session/context-gc-checkpoint.js';
+import { inputMetadataFromRecord } from '../../session/store/index.js';
+import { contextGcTargetKey, latestValidContextGcCheckpoint } from '../../session/context-gc-checkpoint.js';
 import { TOOL_EXECUTION_LIMITS } from '../../tools/execution-limits.js';
 import { replaceReadContextItems } from '../../tools/local/read-context.js';
 import { parseCodeCalls, parseObservations, renderObservationResult } from '../../tools/code-mode/observations.js';
@@ -285,13 +285,11 @@ function targetFromMessage(record, message) {
         recordId: record.recordId,
         role: message.role,
         ...(callId === undefined ? {} : { callId }),
-        ...(toolName === undefined ? {} : { toolName }),
-        sourceHash: contextGcRecordSourceHash(record)
+        ...(toolName === undefined ? {} : { toolName })
     };
 }
 function targetMatchesReplacement(left, right) {
     return (contextGcTargetKey(left) === contextGcTargetKey(right) &&
-        left.sourceHash === right.sourceHash &&
         (right.toolName === undefined || right.toolName === left.toolName));
 }
 function cloneMessage(message) {

package/dist/agent-core/runtime/context/restore.d.ts

@@ -1,19 +1,19 @@
 import type { ModelMessage } from '../../model/contracts.js';
-import { type CompactUserInput, type JsonlSessionStore } from '../../session/jsonl-store.js';
+import { type CompactUserInput, type JsonlSessionStore } from '../../session/store/index.js';
 import type { EnvironmentContextState } from './contracts.js';
 import { type ContextProjection } from './projection.js';
-export declare function restoreMessages(store: JsonlSessionStore, sessionId: string, records: readonly import('../../session/jsonl-store.js').SessionRecord[], options: {
+export declare function restoreMessages(store: JsonlSessionStore, sessionId: string, records: readonly import('../../session/store/index.js').SessionRecord[], options: {
     includeImages: boolean;
     strictImages?: boolean;
     currentTurnId?: string;
     projection?: ContextProjection;
-    messageSources?: WeakMap<ModelMessage, import('../../session/jsonl-store.js').SessionRecord>;
+    messageSources?: WeakMap<ModelMessage, import('../../session/store/index.js').SessionRecord>;
 }): Promise<{
     toolOutcomes: WeakMap<ModelMessage, {
         isError: boolean;
         result?: unknown;
     }>;
-    pendingInputs: Map<string, import("../../session/jsonl-store.js").SessionRecord>;
+    pendingInputs: Map<string, import("../../session/store/types.js").SessionRecord>;
     environmentState: EnvironmentContextState | undefined;
     userMessages: CompactUserInput[];
     messages: ModelMessage[];

package/dist/agent-core/runtime/context/restore.js

@@ -1,6 +1,6 @@
 import { MarAgentError } from '../../error.js';
 import { appliedInputRecord, pendingDeferredInputs } from '../../session/deferred-input.js';
-import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint, inputMetadataFromRecord } from '../../session/jsonl-store.js';
+import { compactSummaryFromCheckpoint, replacementHistoryFromCheckpoint, inputMetadataFromRecord } from '../../session/store/index.js';
 import { compactedHistoryMessages, continuationMessage } from '../compaction/history.js';
 import { restoreCompactTail } from '../compaction/retained-context.js';
 import { environmentContextUpdate, restoreEnvironmentState } from './environment.js';

package/dist/agent-core/runtime/context/usage.d.ts

@@ -6,8 +6,8 @@ export interface AuthoritativeModelUsage {
     readonly historyMessages?: readonly ModelMessage[];
     readonly appendedMessages?: readonly ModelMessage[];
 }
-export declare function latestModelUsage(records: readonly import('../../session/jsonl-store.js').SessionRecord[], selectedModelId: string): AuthoritativeModelUsage | undefined;
-export declare function reasoningEffortBaseline(records: readonly import('../../session/jsonl-store.js').SessionRecord[], modelId: string): MarAgentReasoningEffort | undefined;
+export declare function latestModelUsage(records: readonly import('../../session/store/index.js').SessionRecord[], selectedModelId: string): AuthoritativeModelUsage | undefined;
+export declare function reasoningEffortBaseline(records: readonly import('../../session/store/index.js').SessionRecord[], modelId: string): MarAgentReasoningEffort | undefined;
 export declare function lastConfigurationEffort(messages: readonly ModelMessage[], modelId: string): MarAgentReasoningEffort | undefined;
 export declare function shouldUseNativeCompaction(input: {
     readonly estimatedRequestTokens: number;

package/dist/agent-core/runtime/context/usage.js

@@ -1,6 +1,6 @@
 import { isDeepStrictEqual } from 'node:util';
 import { marAgentReasoningEffortSchema } from '../../model/configuration.js';
-import { compactSummaryFromCheckpoint } from '../../session/jsonl-store.js';
+import { compactSummaryFromCheckpoint } from '../../session/store/index.js';
 import { estimatedRequestTokens } from './request-budget.js';
 export function latestModelUsage(records, selectedModelId) {
     let usage;

package/dist/agent-core/runtime/context/world-state.d.ts

@@ -16,10 +16,10 @@ export interface ContextualWorldState {
     }>;
 }
 export declare function insertContextualWorldState(messages: readonly ModelMessage[], entries: Readonly<ContextualWorldState['entries']>): ModelMessage[];
-export declare function latestContextualWorldStateGeneration(records: readonly import('../../session/jsonl-store.js').SessionRecord[]): string | undefined;
+export declare function latestContextualWorldStateGeneration(records: readonly import('../../session/store/index.js').SessionRecord[]): string | undefined;
 export declare function updatePromptWorldState(state: ContextualWorldState, index: number, parts: readonly ContextualPart[]): ContextualWorldState;
 export declare function parsePersistedContextualWorldState(payload: unknown): ContextualWorldState | undefined;
-export declare function persistContextualWorldState(store: import('../../session/jsonl-store.js').JsonlSessionStore, sessionId: string, state: ContextualWorldState): Promise<void>;
+export declare function persistContextualWorldState(store: import('../../session/store/index.js').JsonlSessionStore, sessionId: string, state: ContextualWorldState): Promise<void>;
 export declare function updateContextualWorldState(state: ContextualWorldState, index: number, current: {
     instructionSnapshot: string | undefined;
     instructionContent: string | undefined;

package/dist/agent-core/runtime/context/world-state.js

@@ -1,7 +1,7 @@
 import { z } from 'zod';
 import { MarAgentError } from '../../error.js';
 import { contextualBlock, contextualChanges } from './contextual-blocks.js';
-import { compactSummaryFromCheckpoint } from '../../session/jsonl-store.js';
+import { compactSummaryFromCheckpoint } from '../../session/store/index.js';
 export function insertContextualWorldState(messages, entries) {
     const result = [...messages];
     // Entries can be restored before the latest user after Compact. Sort anchors,

package/dist/agent-core/sdk/agent.js

@@ -7,7 +7,7 @@ import { negotiateHost } from '../host/contracts.js';
 import { toolCallers } from '../tools/callers.js';
 import { AnthropicMessagesAdapter } from '../model/anthropic-messages.js';
 import { OpenAiResponsesAdapter } from '../model/openai-responses.js';
-import { JsonlSessionStore } from '../session/jsonl-store.js';
+import { JsonlSessionStore } from '../session/store/index.js';
 /** Validate models before Host negotiation and expose only built-in protocol adapters. */
 export async function createMarAgent(options) {
     if (Object.hasOwn(options, 'adapterFactory'))
@@ -100,7 +100,7 @@ export async function createMarAgentWithAdapter(options) {
             return schedule(definition, run);
         },
         baseTools: (id, context) => {
-            const execution = sessionRuntimes.get(id)?.toolSources;
+            const execution = sessionRuntimes.get(id)?.execution?.toolSources;
             if (context?.executionId && execution?.executionId === context.executionId)
                 return execution.bindings;
             return (options.host.extensionPorts?.tools?.catalog(id, context?.executionId) ?? []).map((source) => ({

package/dist/agent-core/sdk/extension-agents.js

@@ -28,7 +28,11 @@ export function createExtensionAgentsBackend(input) {
                     throw new MarAgentError(created.errorCode ?? 'MAR_AGENT_SUBAGENT_FAILED', created.errorMessage ?? 'Agent could not start.');
             }
         })),
-        list: (call) => withController(call, async (controller) => controller.inspectAll()),
+        list: (call) => withController(call, async (controller) => {
+            await controller.prepareAll(call.signal);
+            call.signal.throwIfAborted();
+            return controller.inspectAll();
+        }),
         inspect: (target, call) => withController(call, (controller) => controller.inspect(target.agentId)),
         wait: (target, call) => withController(call, (controller) => {
             const selection = parseAgentWaitTargets(target);

package/dist/agent-core/sdk/native-steer.d.ts

@@ -1,7 +1,7 @@
 import type { CoreOperationContext } from '../extensions/operation.js';
 import { type CorePromptInput, type CorePromptResult } from '../extensions/prompt-input.js';
 import type { SessionInputCoordinator } from '../extensions/session-input.js';
-import type { SessionRecord } from '../session/jsonl-store.js';
+import type { SessionRecord } from '../session/store/index.js';
 import type { SteerInput, SteerResult } from './types.js';
 /** Admission reserves the existing FIFO before any asynchronous Hook or writer work. */
 export declare function createNativeSteer(input: {

package/dist/agent-core/sdk/session.d.ts

@@ -10,13 +10,29 @@ import type { HostDescription, MarAgentHost } from '../host/contracts.js';
 import { type MarAgentReasoningEffort } from '../model/configuration.js';
 import type { ModelAdapter, ModelMessage } from '../model/contracts.js';
 import { CompactRequests } from '../runtime/compaction/requests.js';
-import { JsonlSessionStore } from '../session/jsonl-store.js';
+import { JsonlSessionStore } from '../session/store/index.js';
 import { SubagentSessionController, type SubagentMailboxMessage, type SubagentMessageDelivery, type SubagentTurnHandle } from '../subagent/session-controller.js';
 import { createSessionToolScheduler } from '../tools/scheduler.js';
 import { TodoStore } from '../tools/agent/todo.js';
-import type { CreateMarAgentOptions, ExecutionResult, MarAgentSession } from './types.js';
-export interface SessionRuntime {
+import type { CreateMarAgentOptions, ExecutionMode, ExecutionResult, MarAgentSession } from './types.js';
+interface SessionExecutionContext {
+    readonly executionId: string;
+    readonly modelId: string;
+    readonly mode: ExecutionMode;
+    readonly models: ReadonlyMap<string, ResolvedModelConfiguration>;
+    readonly instruction: string | undefined;
     steer?: (input: import('./types.js').SteerInput) => Promise<import('./types.js').SteerResult>;
+    compactRequests?: CompactRequests;
+    requestMessages?: {
+        read(): readonly ModelMessage[];
+    };
+    appendedMessages?: {
+        append(recordId: string, message: ModelMessage): void;
+    };
+    toolSources?: ExecutionToolSources;
+}
+export interface SessionRuntime {
+    execution?: SessionExecutionContext;
     todo?: TodoStore;
     readonly scheduleTool: ReturnType<typeof createSessionToolScheduler>;
     readonly sourceType: 'user' | 'subagent';
@@ -26,22 +42,12 @@ export interface SessionRuntime {
     subagents?: SubagentSessionController;
     subagentsOpening?: Promise<SubagentSessionController>;
     inputs?: SessionInputCoordinator;
-    compactRequests?: CompactRequests;
     requestSnapshots?: ExtensionRequestSnapshots;
-    requestMessages?: {
-        readonly executionId: string;
-        read(): readonly ModelMessage[];
-    };
     recordProjection?: Promise<unknown>;
-    appendedMessages?: {
-        readonly executionId: string;
-        append(recordId: string, message: ModelMessage): void;
-    };
     sessionBackend?: CoreSessionBackend & {
         kick(): void;
     };
     agentsBackend?: CoreAgentsBackend;
-    toolSources?: ExecutionToolSources;
 }
 interface InternalMarAgentSession extends MarAgentSession {
     startSubagentTurn(input: {