@myagentroam/agent 0.9.169 → 0.9.171

package/dist/agent-core/extensions/compaction.d.ts

@@ -0,0 +1,25 @@
+import type { ModelMessage, ModelUsage } from '../model/contracts.js';
+export interface CoreCompactMessage {
+    readonly role: 'user' | 'assistant' | 'tool' | 'tool_call';
+    readonly content: string;
+    readonly callId?: string;
+    readonly name?: string;
+    readonly arguments?: unknown;
+}
+export interface CoreCompactContext {
+    readonly operationId: string;
+    readonly reason: 'manual' | 'automatic';
+    readonly messages: readonly CoreCompactMessage[];
+    readonly focus?: string;
+    readonly summaryTokenBudget: number;
+    /** Return the Core compaction contract selected for this operation's main model snapshot. */
+    readonly getPrompt: () => string;
+}
+export interface CoreCompactResult {
+    readonly summary: string;
+    readonly usage?: Readonly<ModelUsage>;
+}
+/** Copy only neutral evidence; a hook never receives provider payloads or history ownership. */
+export declare function compactExtensionMessages(messages: readonly ModelMessage[]): readonly CoreCompactMessage[];
+/** Invalid plugin results decline generation rather than altering the checkpoint contract. */
+export declare function compactExtensionResult(value: unknown, budget: number): CoreCompactResult | undefined;

package/dist/agent-core/extensions/compaction.js

@@ -0,0 +1,55 @@
+import { countModelTokens } from '../runtime/token-budget.js';
+/** Copy only neutral evidence; a hook never receives provider payloads or history ownership. */
+export function compactExtensionMessages(messages) {
+    return freeze(messages
+        .filter((message) => message.role !== 'provider' && message.contextKind === undefined)
+        .map((message) => ({
+        role: message.role,
+        content: message.content,
+        ...(message.callId === undefined ? {} : { callId: message.callId }),
+        ...(message.name === undefined ? {} : { name: message.name }),
+        ...(message.arguments === undefined
+            ? {}
+            : { arguments: structuredClone(message.arguments) })
+    })));
+}
+const usageKeys = new Set([
+    'inputTokens',
+    'contextInputTokens',
+    'outputTokens',
+    'cacheReadTokens',
+    'cacheWriteTokens',
+    'rolloutBudgetUnits',
+    'hostedSearches',
+    'hostedFetches'
+]);
+/** Invalid plugin results decline generation rather than altering the checkpoint contract. */
+export function compactExtensionResult(value, budget) {
+    if (value === null ||
+        typeof value !== 'object' ||
+        !('summary' in value) ||
+        typeof value.summary !== 'string')
+        return undefined;
+    const summary = value.summary.trim();
+    if (!summary || countModelTokens(summary) > budget)
+        return undefined;
+    if (!('usage' in value) || value.usage === undefined)
+        return { summary };
+    if (value.usage === null || typeof value.usage !== 'object' || Array.isArray(value.usage))
+        return undefined;
+    const usage = {};
+    for (const [key, amount] of Object.entries(value.usage)) {
+        if (!usageKeys.has(key) || typeof amount !== 'number' || !Number.isFinite(amount) || amount < 0)
+            return undefined;
+        Object.assign(usage, { [key]: amount });
+    }
+    return { summary, usage };
+}
+function freeze(value) {
+    if (value !== null && typeof value === 'object') {
+        for (const child of Object.values(value))
+            freeze(child);
+        Object.freeze(value);
+    }
+    return value;
+}

package/dist/agent-core/extensions/contracts.d.ts

@@ -1,4 +1,5 @@
 import type { CoreModelRequest } from './model-request.js';
+import type { CoreCompactContext, CoreCompactResult } from './compaction.js';
 import type { CorePromptInput, CorePromptResult } from './prompt-input.js';
 import type { CoreModelEvent } from './model-stream.js';
 import type { CorePromptComposition, CorePromptSectionInput } from './prompt-composition.js';
@@ -115,6 +116,10 @@ export interface CoreDomainOperations extends CoreFileOperations {
         input: CoreCompactInput;
         output: CoreSessionActionResult;
     };
+    'compact.generate': {
+        input: CoreCompactContext;
+        output: CoreCompactResult | undefined;
+    };
 }
 export interface CoreDomainFacts {
     'session.ending': {

package/dist/agent-core/model/anthropic-messages.js

@@ -117,9 +117,9 @@ export class AnthropicMessagesAdapter {
                 responseId = text(message.id) ?? responseId;
                 yield { type: 'response.started', responseId };
                 const usage = record(message.usage);
-                const inputTokens = number(usage.input_tokens);
-                const cacheReadTokens = number(usage.cache_read_input_tokens);
-                const cacheWriteTokens = number(usage.cache_creation_input_tokens);
+                const inputTokens = inputTokenCount(usage.input_tokens);
+                const cacheReadTokens = inputTokenCount(usage.cache_read_input_tokens);
+                const cacheWriteTokens = inputTokenCount(usage.cache_creation_input_tokens);
                 latestInputUsage = inputUsage(inputTokens, cacheReadTokens, cacheWriteTokens);
                 yield {
                     type: 'usage',
@@ -334,12 +334,13 @@ export class AnthropicMessagesAdapter {
                 }
                 pendingTextBlocks.clear();
                 const usage = record(event.usage);
-                const inputTokens = number(usage.input_tokens);
-                const cacheReadTokens = number(usage.cache_read_input_tokens);
-                const cacheWriteTokens = number(usage.cache_creation_input_tokens);
-                const deltaInputUsage = inputUsage(inputTokens, cacheReadTokens, cacheWriteTokens);
-                if ((deltaInputUsage.contextInputTokens ?? 0) > 0)
-                    latestInputUsage = deltaInputUsage;
+                const inputTokens = inputTokenCount(usage.input_tokens);
+                const cacheReadTokens = inputTokenCount(usage.cache_read_input_tokens);
+                const cacheWriteTokens = inputTokenCount(usage.cache_creation_input_tokens);
+                // Some compatible gateways emit a complete all-zero input placeholder at the end.
+                const zeroPlaceholder = inputTokens === 0 && cacheReadTokens === 0 && cacheWriteTokens === 0;
+                if (!zeroPlaceholder)
+                    latestInputUsage = inputUsage(inputTokens ?? latestInputUsage?.inputTokens, cacheReadTokens ?? latestInputUsage?.cacheReadTokens, cacheWriteTokens ?? latestInputUsage?.cacheWriteTokens);
                 yield {
                     type: 'usage',
                     usage: {
@@ -439,6 +440,9 @@ function retryAfter(error) {
     const value = error.details?.retryAfter;
     return typeof value === 'string' ? value : null;
 }
+function inputTokenCount(value) {
+    return typeof value === 'number' && Number.isSafeInteger(value) && value >= 0 ? value : undefined;
+}
 function inputUsage(inputTokens, cacheReadTokens, cacheWriteTokens) {
     return {
         inputTokens,

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

@@ -17,6 +17,8 @@ export declare class CompactionOperation {
     readonly signal: AbortSignal;
     constructor(parent: AbortSignal, record: (progress: CompactionProgress) => void | Promise<void>);
     start(model: Pick<ModelTurnSession, 'start'>, request: ModelRequest): AsyncIterable<ModelEvent>;
+    /** External generation shares this operation's deadline, including the default fallback. */
+    generate<T>(run: (signal: AbortSignal) => Promise<T>): Promise<T>;
     dispose(): Promise<void>;
     private report;
 }

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

@@ -61,6 +61,26 @@ export class CompactionOperation {
             throw error;
         }
     }
+    /** External generation shares this operation's deadline, including the default fallback. */
+    async generate(run) {
+        this.signal.throwIfAborted();
+        let abort;
+        try {
+            return await Promise.race([
+                Promise.resolve().then(() => run(this.signal)),
+                new Promise((_resolve, reject) => {
+                    abort = () => reject(this.signal.reason);
+                    this.signal.addEventListener('abort', abort, { once: true });
+                    if (this.signal.aborted)
+                        abort();
+                })
+            ]);
+        }
+        finally {
+            if (abort)
+                this.signal.removeEventListener('abort', abort);
+        }
+    }
     async dispose() {
         if (this.#closed)
             return;

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

@@ -11,6 +11,7 @@ import { discoveredMcpToolNames, rebindMcpToolSearchOutputs } from '../tools/mcp
 import { currentExecutionImages } from '../tools/output-projection.js';
 import { createHash, randomUUID } from 'node:crypto';
 import { ExecutionToolSources } from './extension-tools.js';
+import { compactExtensionMessages, compactExtensionResult } from '../extensions/compaction.js';
 import { ExtensionRequestBridge, ExtensionRequestSnapshots } from '../extensions/model-request.js';
 import { normalizeSessionMessagesInput, sessionMessagesPage } from '../extensions/session-messages.js';
 import { transformCoreModelStream } from '../extensions/model-stream.js';
@@ -1013,7 +1014,37 @@ export function createSessionOpener(services) {
                             : buildExecutionSystemPrompt();
                         let useManualCompactionFallback;
                         const manualAppendBoundary = pendingAppends.length;
-                        if (mode === 'compact') {
+                        const generateCompactExtension = async (history, reason, focus, compaction) => {
+                            if (!coreExtensions.hooks.hasInterceptors('compact.generate'))
+                                return undefined;
+                            const summaryTokenBudget = Math.min(10_000, selectedModel.maxOutputTokens, Math.max(1, Math.floor(selectedModel.contextWindowTokens / 4)));
+                            const highDensityCompaction = selectedModel.highDensityCompaction;
+                            try {
+                                const result = await compaction.generate((signal) => operation((call) => coreExtensions.hooks.invoke('compact.generate', Object.freeze({
+                                    operationId: call.operationId,
+                                    reason,
+                                    messages: compactExtensionMessages(history),
+                                    ...(focus === undefined ? {} : { focus }),
+                                    summaryTokenBudget,
+                                    getPrompt: () => buildCompactionMessages('', highDensityCompaction)[1].content
+                                }), Object.freeze({ ...call, signal }), async () => undefined)));
+                                compaction.signal.throwIfAborted();
+                                return compactExtensionResult(result, summaryTokenBudget);
+                            }
+                            catch {
+                                compaction.signal.throwIfAborted();
+                                return undefined;
+                            }
+                        };
+                        let manualExtension;
+                        if (mode === 'compact' && coreExtensions.hooks.hasInterceptors('compact.generate')) {
+                            manualCompactionStarted = true;
+                            manualCompaction = createCompactionOperation(manualCompactionId, compactSignal);
+                            await emit({ type: 'context.compacting', compactionId: manualCompactionId });
+                            rolloutBudget?.assertAvailable();
+                            manualExtension = await generateCompactExtension(messages, 'manual', compactFocus, manualCompaction);
+                        }
+                        if (mode === 'compact' && manualExtension === undefined) {
                             const compactSystemPrompt = initialSystemPrompt;
                             const compactHistory = [...messages];
                             const projectedHistory = normalizeMessagesForModel(insertContextualWorldState(compactHistory, contextualWorldState.entries), { supportsImages: false });
@@ -1079,8 +1110,6 @@ export function createSessionOpener(services) {
                             });
                             const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages('', selectedModel.highDensityCompaction), executionTools);
                             const compactInputTokens = Math.max(0, selectedModel.contextWindowTokens - compactOverheadTokens);
-                            if (compactInputTokens === 0)
-                                throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Compaction prompt exceeds the selected model context window.');
                             let usingNativeMessages = shouldUseNativeCompaction({
                                 estimatedRequestTokens: estimatedRequestTokens(compactSystemPrompt, nativeCompactMessages, executionTools),
                                 contextWindowTokens: selectedModel.contextWindowTokens,
@@ -1101,7 +1130,16 @@ export function createSessionOpener(services) {
                             const compactionRetryState = { attempts: 0 };
                             const compaction = createCompactionOperation(compactionId, signal);
                             try {
-                                while (true) {
+                                const extensionResult = await generateCompactExtension(compactHistory, 'automatic', input.focus, compaction);
+                                if (extensionResult) {
+                                    compactSummary = extensionResult.summary;
+                                    latestUsage = extensionResult.usage;
+                                    if (latestUsage)
+                                        await emit({ type: 'usage.updated', ...publicModelUsage(latestUsage) });
+                                }
+                                while (extensionResult === undefined) {
+                                    if (compactInputTokens === 0)
+                                        throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Compaction prompt exceeds the selected model context window.');
                                     compactSummary = '';
                                     latestUsage = undefined;
                                     try {
@@ -1172,6 +1210,7 @@ export function createSessionOpener(services) {
                                 }, options);
                                 messages.splice(0, messages.length, environmentContextUpdate(executionEnvironment), ...compactedHistoryMessages(replacementHistory), ...retainedModelContext);
                                 pendingAppends.length = 0;
+                                selected.resetContinuation?.();
                                 return record;
                             });
                             contextGc.reset();
@@ -1385,7 +1424,15 @@ export function createSessionOpener(services) {
                                 }
                             }
                         });
-                        const completed = await executionLoop.run();
+                        if (manualExtension) {
+                            rolloutBudget?.recordUsage(manualExtension.usage);
+                            rolloutBudget?.assertAvailable();
+                            if (manualExtension.usage)
+                                await emit({ type: 'usage.updated', ...publicModelUsage(manualExtension.usage) });
+                        }
+                        const completed = manualExtension
+                            ? { finalAnswer: manualExtension.summary, usage: manualExtension.usage }
+                            : await executionLoop.run();
                         finalAnswer = completed.finalAnswer;
                         const compactSummary = mode === 'compact' ? finalAnswer.trim() : '';
                         if (manualCompaction) {
@@ -1410,6 +1457,7 @@ export function createSessionOpener(services) {
                                 }, options);
                                 messages.splice(0, messages.length, ...compactedHistoryMessages(replacementHistory), ...retainedModelContext);
                                 pendingAppends.length = 0;
+                                selected.resetContinuation?.();
                                 return record;
                             });
                         if (mode === 'compact' && manualCompactionId !== undefined)

package/dist/index.d.ts

@@ -8,10 +8,14 @@ export { testMarAgentModelTransport } from './agent-core/model/transport-test.js
 export type { AccessMode, ExecutionMode, ExecutionResult, MarAgentImageMetadata, RolloutBudgetOptions, RunInput, RunInputImage } from './agent-core/runtime/contracts.js';
 export type { MarAgentEvent } from './agent-core/runtime/events.js';
 export { createMarAgent } from './agent-core/sdk/agent.js';
+export { generateModelText, type GenerateModelTextInput } from './shared/model-text.js';
 export type { CoreAgentExtensionContext, CoreSessionExtensionContext, CoreRuntimeExtension, CoreExtensionSnapshot, CoreExtensionSource, CoreExtensionDiagnostic, CoreDomainOperations, CoreDomainFacts, CoreHookRegistrar, CoreCapabilitySnapshot, CoreCommandSpec, CorePromptSection, CoreServiceDeclaration, CoreServiceDependency } from './agent-core/extensions/contracts.js';
 export type { CoreDisposer, CoreResourceRegistration, CoreResourceScope } from './agent-core/extensions/resources.js';
 export type { CoreHookOptions, CoreInterceptor } from './agent-core/extensions/hooks.js';
 export type { CoreOperationContext } from './agent-core/extensions/operation.js';
+export type { CoreCompactContext, CoreCompactMessage, CoreCompactResult } from './agent-core/extensions/compaction.js';
+export { buildCompactionInput as buildCompactEvidence } from './agent-core/runtime/compaction/history.js';
+export { countModelTokens } from './agent-core/runtime/token-budget.js';
 export type { CoreServiceKey, CoreServiceRegistry } from './agent-core/extensions/services.js';
 export type { CoreToolSpec, CoreToolRef, CoreToolInvocation, CoreToolCheck, CoreToolAttempt, CoreToolCompletion, CoreToolFailure } from './agent-core/extensions/tools.js';
 export type { CoreModelMessage, CoreModelRequest, CoreRequestSnapshot } from './agent-core/extensions/model-request.js';

package/dist/index.js

@@ -4,6 +4,9 @@ export { LocalAgentHost, selectExecutionShell } from './agent-core/host/local-ag
 export { SecretValue, marAgentReasoningEffortSchema, parseModelCatalog, resolveModelDefaultReasoningEffort } from './agent-core/model/configuration.js';
 export { testMarAgentModelTransport } from './agent-core/model/transport-test.js';
 export { createMarAgent } from './agent-core/sdk/agent.js';
+export { generateModelText } from './shared/model-text.js';
+export { buildCompactionInput as buildCompactEvidence } from './agent-core/runtime/compaction/history.js';
+export { countModelTokens } from './agent-core/runtime/token-budget.js';
 export { generateSessionTitle } from './shared/auto-title.js';
 export { openMarAgentSessionCatalog } from './agent-core/session/catalog.js';
 export { MCP_DEFINITION_LIMITS, assertMcpToolCatalog, assertMcpToolDefinition } from './agent-core/tools/mcp/catalog.js';

package/dist/shared/model-text.d.ts

@@ -0,0 +1,16 @@
+import { type MarAgentModelConfiguration, type MarAgentReasoningEffort } from '../agent-core/model/configuration.js';
+import type { ModelUsage } from '../agent-core/model/contracts.js';
+import type { CoreCompactMessage } from '../agent-core/extensions/compaction.js';
+export interface GenerateModelTextInput {
+    readonly model: MarAgentModelConfiguration;
+    readonly system: string;
+    readonly messages: readonly CoreCompactMessage[];
+    readonly reasoningEffort?: MarAgentReasoningEffort;
+    readonly outputLimit?: number;
+    readonly signal: AbortSignal;
+}
+/** One tool-free request using the SDK transports. Credential providers remain caller-owned. */
+export declare function generateModelText(input: GenerateModelTextInput): Promise<{
+    text: string;
+    usage?: ModelUsage;
+} | undefined>;

package/dist/shared/model-text.js

@@ -0,0 +1,43 @@
+import { MarAgentError } from '../agent-core/error.js';
+import { AnthropicMessagesAdapter } from '../agent-core/model/anthropic-messages.js';
+import { OpenAiResponsesAdapter } from '../agent-core/model/openai-responses.js';
+import { resolveModelDefaultReasoningEffort } from '../agent-core/model/configuration.js';
+/** One tool-free request using the SDK transports. Credential providers remain caller-owned. */
+export async function generateModelText(input) {
+    input.signal.throwIfAborted();
+    if (!input.model.enabled)
+        return undefined;
+    const adapter = input.model.protocol === 'OPENAI_RESPONSES'
+        ? new OpenAiResponsesAdapter(input.model)
+        : new AnthropicMessagesAdapter(input.model);
+    let text = '';
+    let completed = false;
+    let usage;
+    try {
+        for await (const event of adapter.start({
+            retryState: { attempts: 0, maxAttempts: 1 },
+            system: input.system,
+            messages: input.messages,
+            tools: [],
+            allowTools: false,
+            toolChoice: 'none',
+            reasoningEffort: input.reasoningEffort ?? resolveModelDefaultReasoningEffort(input.model),
+            ...(input.outputLimit === undefined ? {} : { outputLimit: input.outputLimit })
+        }, input.signal)) {
+            input.signal.throwIfAborted();
+            if (event.type === 'text.completed' && (event.phase ?? 'final_answer') === 'final_answer')
+                text = event.text.trim();
+            else if (event.type === 'usage')
+                usage = event.usage;
+            else if (event.type === 'completed')
+                completed = event.reason === 'completed';
+            else if (event.type === 'client_tool.call')
+                throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Text generation returned a tool call while tools were disabled.');
+        }
+        input.signal.throwIfAborted();
+        return completed && text ? { text, ...(usage === undefined ? {} : { usage }) } : undefined;
+    }
+    finally {
+        await adapter.close?.();
+    }
+}

package/package.json

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