@myagentroam/agent 0.12.8 → 0.12.9

package/dist/runtime/compaction/generate.d.ts

@@ -7,6 +7,7 @@ import { type AuthoritativeModelUsage } from '../context/usage.js';
 import type { CompactionOperation } from './operation.js';
 interface CompactionSnapshot {
     readonly history: readonly ModelMessage[];
+    readonly requestMessages: readonly ModelMessage[];
     readonly system: string;
     readonly systemBlocks?: ModelRequest['systemBlocks'];
     readonly tools: readonly ClientToolDefinition[];

package/dist/runtime/compaction/generate.js

@@ -1,17 +1,12 @@
 import { AgentError } from '../../error.js';
 import { isProviderContextOverflow, recoverModelStream } from '../../model/recovery.js';
-import { normalizeMessagesForModel } from '../context/normalize.js';
 import { estimatedRequestTokens } from '../context/request-budget.js';
 import { shouldUseNativeCompaction } from '../context/usage.js';
 import { buildCompactionInput, buildCompactionMessages, buildNativeCompactionMessages } from './history.js';
-import { projectSmartCompactionMessage } from './smart.js';
 /** Generate a candidate from an isolated snapshot; never commit or adopt active context. */
 export async function generateCompactionCandidate(snapshot, dependencies) {
     const { operation, turn } = dependencies;
-    const projectedHistory = normalizeMessagesForModel(snapshot.history, {
-        supportsImages: false
-    }).map(projectSmartCompactionMessage);
-    const nativeMessages = buildNativeCompactionMessages(projectedHistory, {
+    const nativeMessages = buildNativeCompactionMessages(snapshot.requestMessages, {
         ...(snapshot.focus === undefined ? {} : { focus: snapshot.focus })
     });
     const overhead = estimatedRequestTokens(snapshot.system, buildCompactionMessages(''), snapshot.tools);
@@ -21,7 +16,7 @@ export async function generateCompactionCandidate(snapshot, dependencies) {
         contextWindowTokens: snapshot.contextWindowTokens,
         latestUsage: snapshot.latestUsage,
         historyMessages: snapshot.history,
-        appendedMessages: nativeMessages.slice(projectedHistory.length)
+        appendedMessages: nativeMessages.slice(-1)
     });
     const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(snapshot.history, {
         ...(snapshot.focus === undefined ? {} : { focus: snapshot.focus }),

package/dist/runtime/compaction/history.js

@@ -6,7 +6,7 @@ export function buildNativeCompactionMessages(messages, input = {}) {
     const contract = compactionPrompt();
     return [
         ...messages
-            .filter((message) => message.contextKind !== 'private')
+            .filter((message) => message.contextKind !== 'private' || message.role === 'provider')
             .map((message) => {
             if (!message.images?.length)
                 return message;

package/dist/sdk/execution-compaction.d.ts

@@ -1,5 +1,5 @@
 import { splitContextualPrompt } from '../runtime/context/contextual-blocks.js';
-import type { SessionModelMessage } from '../session/model-request.js';
+import type { SessionModelMessage, SessionModelRequest } from '../session/model-request.js';
 import type { SessionRecord } from '../session/record-contract.js';
 import type { SessionStore } from '../session/store/contracts.js';
 import type { ClientToolDefinition } from '../tools/contracts.js';
@@ -11,7 +11,7 @@ import type { ResourceInputProjection } from './resource-input.js';
 import type { createExecutionModelContext } from './execution-model-context.js';
 import type { generateExecutionCompaction } from './execution-compact-generation.js';
 type Snapshot = Parameters<typeof generateExecutionCompaction>[0]['snapshot'];
-/** Snapshots one Compact prefix, generates a candidate and adopts only its committed checkpoint. */
+/** Snapshots durable evidence and its request projection separately; adopts only a committed checkpoint. */
 export declare function createExecutionCompaction(ports: {
     readonly mode: 'run' | 'plan' | 'compact';
     readonly sessionId: string;
@@ -29,6 +29,7 @@ export declare function createExecutionCompaction(ports: {
     boundary(): number;
     updateBoundary(value: number): void;
     snapshotTools(): readonly ClientToolDefinition[];
+    projectRequest(history: readonly SessionModelMessage[], tools: readonly ClientToolDefinition[]): Pick<SessionModelRequest, 'messages' | 'tools'>;
     usage(): Snapshot['latestUsage'];
     effort(): Snapshot['reasoningEffort'];
     environment(): EnvironmentContextState;

package/dist/sdk/execution-compaction.js

@@ -2,7 +2,7 @@ import { splitContextualPrompt } from '../runtime/context/contextual-blocks.js';
 import { compactSnapshotAnchor } from '../runtime/compaction/retained-context.js';
 import { buildCompactedHistory } from '../runtime/compaction/history.js';
 import { commitExecutionCompaction } from './execution-compact-commit.js';
-/** Snapshots one Compact prefix, generates a candidate and adopts only its committed checkpoint. */
+/** Snapshots durable evidence and its request projection separately; adopts only a committed checkpoint. */
 export function createExecutionCompaction(ports) {
     return async (input, signal, prepare, compactionId) => {
         const { messages, modelContext } = ports;
@@ -18,6 +18,7 @@ export function createExecutionCompaction(ports) {
             return false;
         const history = structuredClone(prefix).map(({ images: _images, ...message }) => message);
         const tools = structuredClone(ports.snapshotTools());
+        const request = structuredClone(ports.projectRequest(history, tools));
         const generation = modelContext.worldState.generation;
         const usage = ports.usage();
         const effort = ports.effort();
@@ -39,11 +40,12 @@ export function createExecutionCompaction(ports) {
         });
         const candidate = await ports.generate({
             history,
+            requestMessages: request.messages,
             system: composition.system,
             ...(composition.systemBlocks === undefined
                 ? {}
                 : { systemBlocks: composition.systemBlocks }),
-            tools,
+            tools: request.tools,
             contextWindowTokens: ports.model.contextWindowTokens,
             latestUsage: usage,
             reasoningEffort: effort,

package/dist/sdk/request-preparation.d.ts

@@ -5,5 +5,7 @@ import type { AgentModelConfiguration } from '../model/configuration.js';
 import { type ContextualWorldState } from '../runtime/context/world-state.js';
 /** Assemble captured round values only. Admission, Hooks and publication belong to Session. */
 export declare function prepareSessionModelRequest(candidate: ModelRequest, model: Pick<AgentModelConfiguration, 'protocol' | 'inputCapabilities'>, entries: ContextualWorldState['entries'], residentTools: readonly ClientToolDefinition[], autoPermission: boolean): ModelRequest;
+/** Conversation and Compact keep identical Code Mode and native discovery tool prefixes. */
+export declare function projectSessionRequestTools(model: Pick<AgentModelConfiguration, 'protocol'>, tools: readonly ClientToolDefinition[], residentTools: readonly ClientToolDefinition[]): readonly ClientToolDefinition[];
 /** The actual candidate and current Session view share the same side-effect-free projection. */
 export declare function projectSessionRequestMessages(messages: readonly ModelMessage[], entries: ContextualWorldState['entries'], supportsImages: boolean, codeMode: boolean, autoPermission?: boolean): ModelMessage[];

package/dist/sdk/request-preparation.js

@@ -10,9 +10,13 @@ export function prepareSessionModelRequest(candidate, model, entries, residentTo
     return {
         ...candidate,
         messages: projectSessionRequestMessages(candidate.messages, entries, model.inputCapabilities.includes('IMAGE'), codeMode, autoPermission),
-        tools: projectModelRequestTools(model, projectCodeModeTools(candidate.tools, residentTools), new Set(residentTools.map((tool) => tool.name)))
+        tools: projectSessionRequestTools(model, candidate.tools, residentTools)
     };
 }
+/** Conversation and Compact keep identical Code Mode and native discovery tool prefixes. */
+export function projectSessionRequestTools(model, tools, residentTools) {
+    return projectModelRequestTools(model, projectCodeModeTools(tools, residentTools), new Set(residentTools.map((tool) => tool.name)));
+}
 /** The actual candidate and current Session view share the same side-effect-free projection. */
 export function projectSessionRequestMessages(messages, entries, supportsImages, codeMode, autoPermission = false) {
     return normalizeMessagesForModel(insertContextualWorldState(messages, entries), {

package/dist/sdk/session-execution-factory.js

@@ -20,7 +20,7 @@ import { prepareExecutionRoundRequest } from './execution-round-request.js';
 import { ExecutionToolCatalog, initializeExecutionToolCatalog } from './execution-tool-catalog.js';
 import { createExecutionToolScope } from './execution-tool-scope.js';
 import { createNativeSteer } from './native-steer.js';
-import { projectSessionRequestMessages } from './request-preparation.js';
+import { projectSessionRequestMessages, projectSessionRequestTools } from './request-preparation.js';
 import { ResourceInputProjection } from './resource-input.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { AgentError, describeAgentError } from '../error.js';
@@ -469,7 +469,7 @@ export function createSessionExecutionFactory(ports) {
                             ? normalizeMessagesForModel([...preparingRequestMessages, ...messages.slice(preparingRequestBaseLength)], { supportsImages: selectedModel.inputCapabilities.includes('IMAGE') })
                             : projectSessionRequestMessages(messages.map((message, index) => index === currentExecutionUserIndex && modelInputImages?.length
                                 ? { ...message, images: modelInputImages }
-                                : message), mode === 'compact' ? [] : modelContext.worldState.entries, mode !== 'compact' && selectedModel.inputCapabilities.includes('IMAGE'), baseTools().some((tool) => tool.name === 'code_exec'), permissionPolicy.mode === 'auto')
+                                : message), modelContext.worldState.entries, mode !== 'compact' && selectedModel.inputCapabilities.includes('IMAGE'), baseTools().some((tool) => tool.name === 'code_exec'), permissionPolicy.mode === 'auto')
                     }
                 });
                 if (mode !== 'compact') {
@@ -618,6 +618,10 @@ export function createSessionExecutionFactory(ports) {
                             contextCoordinator.setBoundary(value);
                         },
                         snapshotTools: () => projectTools(toolCatalog.tools),
+                        projectRequest: (history, tools) => ({
+                            messages: projectSessionRequestMessages(history, modelContext.worldState.entries, false, tools.some((tool) => tool.name === 'code_exec'), permissionPolicy.mode === 'auto'),
+                            tools: projectSessionRequestTools(selectedModel, tools, projectTools(mcpRegistry.projectDirect(baseTools())))
+                        }),
                         usage: () => modelLifecycle.usage,
                         effort: () => requestReasoningEffort ?? reasoningEffort,
                         environment: () => executionEnvironment,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@myagentroam/agent",
-  "version": "0.12.8",
+  "version": "0.12.9",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",