@myagentroam/agent 0.9.79 → 0.9.81

package/dist/model/anthropic-messages.js

@@ -72,6 +72,9 @@ export class AnthropicMessagesAdapter {
                 ],
                 messages: anthropicMessages(request.messages, request.images, request.tools, this.configuration.id),
                 tools,
+                ...(request.toolChoice === undefined
+                    ? {}
+                    : { tool_choice: { type: request.toolChoice } }),
                 stream: true,
                 max_tokens: this.configuration.maxOutputTokens,
                 output_config: {

package/dist/model/contracts.d.ts

@@ -60,6 +60,8 @@ export interface ModelRequest {
     messages: readonly ModelMessage[];
     tools: readonly ClientToolDefinition[];
     allowTools?: boolean;
+    /** Preserve the visible tool catalog while controlling whether the model may call it. */
+    toolChoice?: 'auto' | 'none';
     reasoningEffort?: MarAgentReasoningEffort;
     promptCacheKey?: string;
     images?: readonly {

package/dist/model/openai-responses.js

@@ -551,6 +551,7 @@ class OpenAiResponsesTurnSession {
                 this.adapter.configuration.responsesPreviousResponseId &&
                 this.state.lastRequest === undefined &&
                 request.allowTools !== false &&
+                request.toolChoice !== 'none' &&
                 (request.tools.length > 0 || this.adapter.configuration.hostedWebSearch)) {
                 const prefix = prepared.fullBody.input.slice(0, request.system ? 2 : 1);
                 const warmBody = { ...prepared.fullBody, input: prefix, generate: false };
@@ -804,6 +805,7 @@ function responsesRequestBody(configuration, request, messages, prefixIdentity =
             });
     if (request.allowTools !== false && configuration.hostedWebSearch)
         tools.push({ type: 'web_search' });
+    const toolChoice = request.toolChoice ?? 'auto';
     const lite = configuration.responsesEncoding === 'LITE';
     const input = openAiInput(messages, request.images, configuration.id, true);
     if (lite) {
@@ -829,10 +831,10 @@ function responsesRequestBody(configuration, request, messages, prefixIdentity =
         model: configuration.modelId,
         ...(lite
             ? {
-                tool_choice: 'auto',
+                tool_choice: toolChoice,
                 client_metadata: { [RESPONSES_LITE_METADATA]: 'true' }
             }
-            : { instructions: request.system, tools }),
+            : { instructions: request.system, tools, tool_choice: toolChoice }),
         input,
         stream: true,
         parallel_tool_calls: !lite,

package/dist/runtime/compact.d.ts

@@ -22,6 +22,10 @@ export declare class CompactionOperation {
     private report;
 }
 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;
+    highDensityCompaction?: boolean;
+}): ModelMessage[];
 export declare function buildCompactionMessages(evidence: string, highDensityCompaction?: boolean): ModelMessage[];
 export declare function buildCompactionInput(messages: readonly ModelMessage[], input: {
     focus?: string;

package/dist/runtime/compact.js

@@ -91,6 +91,23 @@ export class CompactionOperation {
     }
 }
 export const DEFAULT_COMPACTION_FOCUS = 'Create a durable continuation state for the next model invocation.';
+export function buildNativeCompactionMessages(messages, input = {}) {
+    const focus = input.focus?.trim();
+    const contract = input.highDensityCompaction ? highDensityCompactionPrompt() : compactionPrompt();
+    return [
+        ...messages.map((message) => {
+            if (!message.images?.length)
+                return message;
+            const textOnly = { ...message };
+            delete textOnly.images;
+            return textOnly;
+        }),
+        {
+            role: 'user',
+            content: focus ? `Compaction focus: ${focus}\n\n${contract}` : contract
+        }
+    ];
+}
 export function buildCompactionMessages(evidence, highDensityCompaction = false) {
     return [
         { role: 'user', content: evidence },

package/dist/sdk/agent.js

@@ -14,7 +14,7 @@ import { ContextGcRuntime } from '../runtime/context-gc-runtime.js';
 import { buildContextProjection } from '../runtime/context-projection.js';
 import { countModelTokens, countTextLines, truncateModelText } from '../runtime/token-budget.js';
 import { TOOL_EXECUTION_LIMITS } from '../tools/execution-limits.js';
-import { DEFAULT_COMPACTION_FOCUS, CompactionOperation, buildCompactionInput, buildCompactionMessages, buildCompactedHistory, compactedHistoryMessages, continuationMessage } from '../runtime/compact.js';
+import { DEFAULT_COMPACTION_FOCUS, CompactionOperation, buildCompactionInput, buildCompactionMessages, buildNativeCompactionMessages, buildCompactedHistory, compactedHistoryMessages, continuationMessage } from '../runtime/compact.js';
 import { buildSystemPrompt, MAR_AGENT_PROMPT_VERSION } from '../prompts/index.js';
 import { buildEnvironmentContext } from '../prompts/core.js';
 import { modelOutputContinuationMessage } from '../prompts/output.js';
@@ -427,30 +427,27 @@ export async function createMarAgent(options) {
                                                 : tool.name !== 'web_fetch' ||
                                                     description.capabilities.includes('web.fetch');
                     });
-                    const instructionContext = mode === 'compact'
-                        ? undefined
-                        : await loadAgentInstructions({
-                            home: description.homeDirectory,
-                            workspace: instructionWorkspace,
-                            availableTools: new Set(availableTools.map((tool) => tool.name)),
-                            ...(options.workspaceMapping === undefined
-                                ? {}
-                                : { workspaceDisplayPath: logicalWorkspace })
-                        });
-                    let agentInstructionMessage = mode === 'compact'
-                        ? undefined
-                        : renderAgentInstructions(instructionContext?.entries ?? [], previousMayContainAgentInstructions);
-                    let agentInstructionInsertIndex = mode === 'compact' ? undefined : Math.max(0, messages.length - 1);
-                    if (agentInstructionInsertIndex &&
+                    const instructionContext = await loadAgentInstructions({
+                        home: description.homeDirectory,
+                        workspace: instructionWorkspace,
+                        availableTools: new Set(availableTools.map((tool) => tool.name)),
+                        ...(options.workspaceMapping === undefined
+                            ? {}
+                            : { workspaceDisplayPath: logicalWorkspace })
+                    });
+                    let agentInstructionMessage = renderAgentInstructions(instructionContext?.entries ?? [], previousMayContainAgentInstructions);
+                    let agentInstructionInsertIndex = mode === 'compact'
+                        ? contextualInstructionInsertIndex(messages)
+                        : Math.max(0, messages.length - 1);
+                    if (mode !== 'compact' &&
+                        agentInstructionInsertIndex &&
                         messages[agentInstructionInsertIndex - 1]?.contextKind === 'environment')
                         agentInstructionInsertIndex--;
                     const tools = withCodeModeResultTypes(availableTools.filter((tool) => tool.name !== 'skill' || (instructionContext?.skills.size ?? 0) > 0));
-                    const executionTools = mode === 'compact' ? [] : tools;
-                    const hostResources = mode === 'compact'
-                        ? { processes: [] }
-                        : ((await options.host.listSessionResources?.(sessionId)) ?? {
-                            processes: []
-                        });
+                    const executionTools = tools;
+                    const hostResources = (await options.host.listSessionResources?.(sessionId)) ?? {
+                        processes: []
+                    };
                     const retainedSessionResources = {
                         ...(hostResources.idleTtlMs === undefined
                             ? {}
@@ -458,8 +455,8 @@ export async function createMarAgent(options) {
                         processes: hostResources.processes,
                         subagents: subagents?.listSessionResources() ?? []
                     };
-                    const buildExecutionSystemPrompt = (availableTools = executionTools) => buildSystemPrompt({
-                        mode,
+                    const buildExecutionSystemPrompt = (availableTools = executionTools, promptMode = mode) => buildSystemPrompt({
+                        mode: promptMode,
                         platform: description.platform,
                         ...(description.architecture ? { architecture: description.architecture } : {}),
                         ...(description.shell ? { shell: description.shell } : {}),
@@ -503,16 +500,39 @@ export async function createMarAgent(options) {
                             .filter(Boolean)
                             .join('\n\n')
                     });
-                    const initialSystemPrompt = buildExecutionSystemPrompt();
+                    const initialSystemPrompt = mode === 'compact'
+                        ? buildExecutionSystemPrompt(executionTools, 'run')
+                        : buildExecutionSystemPrompt();
+                    let useManualCompactionFallback;
                     if (mode === 'compact') {
-                        const compactOverheadTokens = estimatedRequestTokens(initialSystemPrompt, buildCompactionMessages('', selectedModel.highDensityCompaction), []);
+                        const compactSystemPrompt = initialSystemPrompt;
+                        const compactHistory = [...messages];
+                        const projectedHistory = normalizeMessagesForModel(insertContextualInstructions(compactHistory, agentInstructionInsertIndex, agentInstructionMessage), { supportsImages: false });
+                        const nativeMessages = buildNativeCompactionMessages(projectedHistory, {
+                            focus: input.prompt,
+                            highDensityCompaction: selectedModel.highDensityCompaction
+                        });
+                        const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages('', selectedModel.highDensityCompaction), executionTools);
                         const compactInputTokens = selectedModel.contextWindowTokens - compactOverheadTokens;
                         if (compactInputTokens <= 0)
                             throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'Compaction prompt exceeds the selected model context window.');
-                        messages.splice(0, messages.length, ...buildCompactionMessages(buildCompactionInput(messages, {
+                        const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(compactHistory, {
                             focus: input.prompt,
                             maxTokens: compactInputTokens
-                        }), selectedModel.highDensityCompaction));
+                        }), selectedModel.highDensityCompaction);
+                        const useNative = estimatedRequestTokens(compactSystemPrompt, nativeMessages, executionTools) <=
+                            selectedModel.contextWindowTokens;
+                        messages.splice(0, messages.length, ...(useNative ? nativeMessages : fallbackMessages()));
+                        if (useNative) {
+                            let available = true;
+                            useManualCompactionFallback = () => {
+                                if (!available)
+                                    return false;
+                                available = false;
+                                messages.splice(0, messages.length, ...fallbackMessages());
+                                return true;
+                            };
+                        }
                     }
                     await store.append(sessionId, {
                         type: 'execution.header',
@@ -535,21 +555,25 @@ export async function createMarAgent(options) {
                             return false;
                         const retainCurrent = current.role === 'user';
                         let compactSummary = '';
-                        const compactSystemPrompt = buildSystemPrompt({
-                            mode: 'compact',
-                            platform: description.platform,
-                            workspace: logicalWorkspace,
-                            tools: [],
-                            highDensityCompaction: selectedModel.highDensityCompaction,
-                            extension: options.systemInstruction
+                        const compactSystemPrompt = buildExecutionSystemPrompt(executionTools, 'run');
+                        const compactHistory = retainCurrent ? messages.slice(0, -1) : messages;
+                        const compactInstructionInsertIndex = retainCurrent
+                            ? contextualInstructionInsertIndex(compactHistory)
+                            : agentInstructionInsertIndex;
+                        const projectedHistory = normalizeMessagesForModel(insertContextualInstructions(compactHistory, compactInstructionInsertIndex, agentInstructionMessage), { supportsImages: false });
+                        const nativeCompactMessages = buildNativeCompactionMessages(projectedHistory, {
+                            highDensityCompaction: selectedModel.highDensityCompaction
                         });
-                        const compactOverheadTokens = estimatedRequestTokens(compactSystemPrompt, buildCompactionMessages('', selectedModel.highDensityCompaction), []);
+                        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.');
-                        const compactSource = buildCompactionInput(retainCurrent ? messages.slice(0, -1) : messages, {
+                        let usingNativeMessages = estimatedRequestTokens(compactSystemPrompt, nativeCompactMessages, executionTools) <=
+                            selectedModel.contextWindowTokens;
+                        const fallbackMessages = () => buildCompactionMessages(buildCompactionInput(compactHistory, {
                             maxTokens: Math.max(1, compactInputTokens)
-                        });
+                        }), selectedModel.highDensityCompaction);
+                        let compactMessages = usingNativeMessages ? nativeCompactMessages : fallbackMessages();
                         const compactionId = randomUUID();
                         await emit({ type: 'context.compacting', compactionId });
                         let latestUsage;
@@ -563,9 +587,9 @@ export async function createMarAgent(options) {
                                     for await (const event of operation.start(selected, {
                                         retryState: compactionRetryState,
                                         system: compactSystemPrompt,
-                                        messages: buildCompactionMessages(compactSource, selectedModel.highDensityCompaction),
-                                        tools: [],
-                                        allowTools: false,
+                                        messages: compactMessages,
+                                        tools: executionTools,
+                                        toolChoice: 'none',
                                         promptCacheKey: sessionId,
                                         onAttemptDiagnostic: recordModelAttempt('COMPACTION')
                                     })) {
@@ -576,6 +600,8 @@ export async function createMarAgent(options) {
                                             latestUsage = event.usage;
                                             await emit({ type: 'usage.updated', ...publicModelUsage(event.usage) });
                                         }
+                                        else if (event.type === 'client_tool.call')
+                                            throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Compaction returned a tool call while tools were disabled.');
                                     }
                                     break;
                                 }
@@ -584,6 +610,13 @@ export async function createMarAgent(options) {
                                         sessionRuntime.responsesChain = undefined;
                                         continue;
                                     }
+                                    if (isProviderContextOverflow(error) && usingNativeMessages) {
+                                        usingNativeMessages = false;
+                                        compactMessages = fallbackMessages();
+                                        compactionRetryState.attempts = 0;
+                                        sessionRuntime.responsesChain = undefined;
+                                        continue;
+                                    }
                                     if (isProviderContextOverflow(error))
                                         throw new MarAgentError('MAR_AGENT_CONTEXT_LIMIT', 'The compaction request exceeds the model context window.', { cause: error });
                                     throw error;
@@ -644,8 +677,10 @@ export async function createMarAgent(options) {
                         let incompleteToolCall = false;
                         await ensureContextBudget();
                         const toolsAllowed = mode !== 'compact' && (!rolloutBudget?.active || rolloutBudget.stage !== 'exhausted');
-                        const roundTools = toolsAllowed ? executionTools : [];
-                        const systemPrompt = buildExecutionSystemPrompt(roundTools);
+                        const roundTools = mode === 'compact' ? executionTools : toolsAllowed ? executionTools : [];
+                        const systemPrompt = mode === 'compact'
+                            ? buildExecutionSystemPrompt(roundTools, 'run')
+                            : buildExecutionSystemPrompt(roundTools);
                         const requestSignature = createHash('sha256')
                             .update(stableJson({
                             modelId: selectedModel.id,
@@ -667,9 +702,11 @@ export async function createMarAgent(options) {
                                 deltaMessages: requestContextMessages.slice(sessionRuntime.responsesChain.messageCount)
                             }
                             : undefined;
-                        const modelMessages = normalizeMessagesForModel(insertContextualInstructions(requestContextMessages, agentInstructionInsertIndex, agentInstructionMessage), {
-                            supportsImages: selectedModel.inputCapabilities.includes('IMAGE')
-                        });
+                        const modelMessages = mode === 'compact'
+                            ? normalizeMessagesForModel(requestContextMessages, { supportsImages: false })
+                            : normalizeMessagesForModel(insertContextualInstructions(requestContextMessages, agentInstructionInsertIndex, agentInstructionMessage), {
+                                supportsImages: selectedModel.inputCapabilities.includes('IMAGE')
+                            });
                         let sawModelSemanticEvent = false;
                         const roundMessageCount = messages.length;
                         const persistToolCalls = async (calls) => {
@@ -705,7 +742,11 @@ export async function createMarAgent(options) {
                                 system: systemPrompt,
                                 messages: modelMessages,
                                 tools: roundTools,
-                                ...(toolsAllowed ? {} : { allowTools: false }),
+                                ...(mode === 'compact'
+                                    ? { toolChoice: 'none' }
+                                    : toolsAllowed
+                                        ? {}
+                                        : { allowTools: false }),
                                 promptCacheKey: sessionId,
                                 ...(continuation ? { continuation } : {}),
                                 reasoningEffort,
@@ -821,6 +862,8 @@ export async function createMarAgent(options) {
                                         });
                                 }
                                 else if (event.type === 'client_tool.call') {
+                                    if (mode === 'compact')
+                                        throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Compaction returned a tool call while tools were disabled.');
                                     sawTool = true;
                                     pendingTools.push(event);
                                 }
@@ -851,6 +894,16 @@ export async function createMarAgent(options) {
                                 if (pendingTools.length === 0)
                                     continue;
                             }
+                            else if (mode === 'compact' &&
+                                !sawModelSemanticEvent &&
+                                isProviderContextOverflow(error) &&
+                                useManualCompactionFallback?.()) {
+                                sessionRuntime.responsesChain = undefined;
+                                modelRetryState.attempts = 0;
+                                responseId = undefined;
+                                finalAnswer = '';
+                                continue;
+                            }
                             else if (mode !== 'compact' &&
                                 !sawModelSemanticEvent &&
                                 isProviderContextOverflow(error)) {
@@ -1652,6 +1705,14 @@ function insertContextualInstructions(messages, index, content, environmentConte
         });
     return result;
 }
+function contextualInstructionInsertIndex(messages) {
+    let index = messages.findLastIndex((message) => message.role === 'user' && message.contextKind !== 'environment');
+    if (index < 0)
+        return 0;
+    if (index > 0 && messages[index - 1]?.contextKind === 'environment')
+        index--;
+    return index;
+}
 function estimatedRequestTokens(system, messages, tools, images) {
     const transientImageCount = messages.reduce((total, message) => total + (message.images?.length ?? 0), images?.length ?? 0);
     const textMessages = messages.map((message) => {

package/package.json

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