@myagentroam/agent 0.9.108 → 0.9.110

package/dist/cli/main.js

@@ -19,7 +19,7 @@ Usage:
   maragent run <prompt> [--reasoning-effort EFFORT] [--format text|json|stream-json] [--codex-auth-file PATH]
   maragent resume [sessionId] [--reasoning-effort EFFORT] [--codex-auth-file PATH]
   maragent sessions list|delete <sessionId>
-  maragent models list|add|edit|remove|test [id] [--default-reasoning-effort EFFORT] [--code-mode|--no-code-mode] [--high-density-compaction|--no-high-density-compaction] [--responses-encoding standard|lite] [--codex-auth-file PATH]
+  maragent models list|add|edit|remove|test [id] [--default-reasoning-effort EFFORT] [--code-mode|--no-code-mode] [--high-density-compaction|--no-high-density-compaction] [--responses-encoding standard|lite] [--fast-mode|--no-fast-mode] [--codex-auth-file PATH]
 `;
 function takeOption(arguments_, name) {
     const index = arguments_.indexOf(name);
@@ -132,6 +132,10 @@ async function modelsCommand(home, arguments_, codexAuthFile) {
     const credential = option('--credential', existing?.credentialSource === 'CODEX_AUTH_FILE' ? 'codex-auth-file' : 'api-key') ?? 'api-key';
     if (credential !== 'api-key' && credential !== 'codex-auth-file')
         throw new MarAgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', '--credential is invalid.');
+    const hasFastModeOption = arguments_.includes('--fast-mode') || arguments_.includes('--no-fast-mode');
+    const fastMode = booleanFlag(arguments_, '--fast-mode', '--no-fast-mode', credential === 'codex-auth-file' ? (existing?.fastMode ?? false) : false);
+    if (hasFastModeOption && (protocol !== 'OPENAI_RESPONSES' || credential !== 'codex-auth-file'))
+        throw new MarAgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', '--fast-mode requires Codex.');
     const readsApiKey = takeFlag(arguments_, '--api-key-stdin');
     if (credential === 'codex-auth-file' && readsApiKey)
         throw new MarAgentError('MAR_AGENT_CLI_ARGUMENT_INVALID', '--api-key-stdin cannot be combined with an external credential.');
@@ -182,6 +186,7 @@ async function modelsCommand(home, arguments_, codexAuthFile) {
         titleGeneration: existing?.titleGeneration ?? false,
         codeMode: booleanFlag(arguments_, '--code-mode', '--no-code-mode', existing?.codeMode ?? false),
         highDensityCompaction: booleanFlag(arguments_, '--high-density-compaction', '--no-high-density-compaction', existing?.highDensityCompaction ?? false),
+        ...(credential === 'codex-auth-file' && fastMode ? { fastMode: true } : {}),
         hostedWebSearch: booleanFlag(arguments_, '--web-search', '--no-web-search', existing?.hostedWebSearch ?? false),
         ...(responsesTransport === undefined ? {} : { responsesTransport }),
         ...(responsesEncoding === undefined ? {} : { responsesEncoding }),
@@ -378,6 +383,7 @@ function runtimeModels(models, codexAuthFile) {
                     {
                         ...configuration,
                         responsesEncoding: configuration.responsesEncoding ?? 'STANDARD',
+                        codexCredential: true,
                         credentialProvider: provider
                     }
                 ];

package/dist/model/catalog-file.d.ts

@@ -11,6 +11,7 @@ export declare function readModelCatalog(home: string): Promise<CliModelCatalog>
 export declare function writeModelCatalog(home: string, catalog: CliModelCatalog): Promise<void>;
 export declare function serializeModel(model: CliModelConfiguration): {
     apiKey: string;
+    codexCredential?: boolean;
     responsesTransport?: import("./configuration.js").ResponsesTransport;
     responsesPreviousResponseId?: boolean;
     id: string;
@@ -27,6 +28,7 @@ export declare function serializeModel(model: CliModelConfiguration): {
     titleGeneration: boolean;
     codeMode: boolean;
     highDensityCompaction: boolean;
+    fastMode?: boolean | undefined;
     hostedWebSearch: boolean;
     responsesEncoding?: "STANDARD" | "LITE" | undefined;
     enabled: boolean;
@@ -34,6 +36,7 @@ export declare function serializeModel(model: CliModelConfiguration): {
     credential: {
         type: "CODEX_AUTH_FILE";
     };
+    codexCredential?: boolean;
     responsesTransport?: import("./configuration.js").ResponsesTransport;
     responsesPreviousResponseId?: boolean;
     id: string;
@@ -50,6 +53,7 @@ export declare function serializeModel(model: CliModelConfiguration): {
     titleGeneration: boolean;
     codeMode: boolean;
     highDensityCompaction: boolean;
+    fastMode?: boolean | undefined;
     hostedWebSearch: boolean;
     responsesEncoding?: "STANDARD" | "LITE" | undefined;
     enabled: boolean;

package/dist/model/configuration.d.ts

@@ -70,6 +70,7 @@ declare const rawModelSchema: z.ZodObject<{
     titleGeneration: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     codeMode: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     highDensityCompaction: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    fastMode: z.ZodOptional<z.ZodBoolean>;
     hostedWebSearch: z.ZodBoolean;
     responsesTransport: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
         transport: z.ZodLiteral<"HTTP">;
@@ -90,6 +91,7 @@ declare const rawModelSchema: z.ZodObject<{
 export interface MarAgentModelConfiguration extends Omit<z.infer<typeof rawModelSchema>, 'apiKey' | 'responsesPreviousResponseId' | 'responsesTransport'> {
     apiKey?: SecretValue;
     credentialProvider?: ModelCredentialProvider;
+    codexCredential?: boolean;
     responsesTransport?: ResponsesTransport;
     responsesPreviousResponseId?: boolean;
 }

package/dist/model/configuration.js

@@ -50,6 +50,7 @@ const rawModelSchema = z
     titleGeneration: z.boolean().optional().default(false),
     codeMode: z.boolean().optional().default(false),
     highDensityCompaction: z.boolean().optional().default(false),
+    fastMode: z.boolean().optional(),
     hostedWebSearch: z.boolean(),
     responsesTransport: rawResponsesTransportSchema.optional(),
     responsesEncoding: z.enum(['STANDARD', 'LITE']).optional(),
@@ -89,6 +90,8 @@ const rawModelSchema = z
         context.addIssue({ code: 'custom', message: 'Responses transport requires Responses.' });
     if (value.protocol !== 'OPENAI_RESPONSES' && value.responsesEncoding !== undefined)
         context.addIssue({ code: 'custom', message: 'Responses encoding requires Responses.' });
+    if (value.protocol !== 'OPENAI_RESPONSES' && value.fastMode === true)
+        context.addIssue({ code: 'custom', message: 'Fast mode requires Responses.' });
 });
 export function resolveModelDefaultReasoningEffort(model) {
     const configured = marAgentReasoningEffortSchema.safeParse(model.defaultReasoningEffort);

package/dist/model/contracts.d.ts

@@ -65,6 +65,8 @@ export interface ModelRequest {
     /** Preserve the visible tool catalog while controlling whether the model may call it. */
     toolChoice?: 'auto' | 'none';
     reasoningEffort?: MarAgentReasoningEffort;
+    /** Stable request-level effort while native configuration updates select the current effort. */
+    requestReasoningEffort?: MarAgentReasoningEffort;
     promptCacheKey?: string;
     images?: readonly {
         mimeType: string;

package/dist/model/openai-responses.js

@@ -1,7 +1,7 @@
 import { isDeepStrictEqual } from 'node:util';
 import { createHash, randomUUID } from 'node:crypto';
 import { describeMarAgentError, MarAgentError } from '../error.js';
-import { resolveModelDefaultReasoningEffort } from './configuration.js';
+import { marAgentReasoningEffortSchema, resolveModelDefaultReasoningEffort } from './configuration.js';
 import WebSocket from 'ws';
 import { isRetryableUpstreamOverloadCode, number, parseSse, record, text } from './sse.js';
 import { connectSocks5Target, fetchModelResponse, isRetryableModelHttpStatus, isRetryableModelTransportError, modelRetryMaxAttempts, isRetryableModelRequestError, modelRetryDelay, waitForModelRetry } from './http.js';
@@ -872,6 +872,7 @@ function responsesRequestBody(configuration, request, messages, prefixIdentity =
     }
     return {
         model: configuration.modelId,
+        ...(configuration.fastMode === true ? { service_tier: 'priority' } : {}),
         ...(lite
             ? {
                 tool_choice: toolChoice,
@@ -886,7 +887,9 @@ function responsesRequestBody(configuration, request, messages, prefixIdentity =
         include: ['reasoning.encrypted_content'],
         ...(request.promptCacheKey ? { prompt_cache_key: request.promptCacheKey } : {}),
         reasoning: {
-            effort: request.reasoningEffort?.trim() || resolveModelDefaultReasoningEffort(configuration),
+            effort: request.requestReasoningEffort?.trim() ||
+                request.reasoningEffort?.trim() ||
+                resolveModelDefaultReasoningEffort(configuration),
             summary: 'auto',
             ...(lite ? { context: 'all_turns' } : {})
         }
@@ -922,6 +925,7 @@ function incrementalResponsesInput(state, current) {
 function responsesContinuationPropertiesMatch(previous, current) {
     const properties = [
         'model',
+        'service_tier',
         'instructions',
         'tools',
         'tool_choice',
@@ -1614,7 +1618,20 @@ export function openAiInput(messages, images, modelId, requireEncryptedReasoning
     for (const message of compatibleMessages)
         if (message.role === 'tool_call' && message.inputMode === 'freeform' && message.callId)
             customCallIds.add(message.callId);
-    return compatibleMessages
+    const orderedMessages = [];
+    for (const message of compatibleMessages) {
+        if (message.role === 'provider' && message.item?.type === 'configuration_update') {
+            const userIndex = orderedMessages.findLastIndex((candidate) => candidate.role === 'user');
+            if (userIndex >= 0) {
+                orderedMessages.splice(userIndex, 0, message);
+                continue;
+            }
+        }
+        orderedMessages.push(message);
+    }
+    // SDK records the update after the user input; the wire item must precede
+    // that user message so the new effort applies to the response.
+    return orderedMessages
         .filter((message) => !(message.role === 'tool_call' && message.callId && providerCallIds.has(message.callId)) &&
         !(message.role === 'assistant' && providerMessageTexts.has(message.content)))
         .map((message) => openAiInputItem(message, message === lastUser ? images : undefined, customCallIds));
@@ -1624,6 +1641,11 @@ function openAiInputItem(message, images, customCallIds = new Set()) {
     if (message.role === 'provider') {
         if (message.provider !== 'OPENAI_RESPONSES' || !message.item)
             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Provider context item is invalid.');
+        if (message.item.type === 'configuration_update') {
+            const effort = marAgentReasoningEffortSchema.safeParse(record(message.item.reasoning).effort);
+            if (effort.success)
+                return { type: 'configuration_update', reasoning: { effort: effort.data } };
+        }
         const item = responseItem(message.item);
         if (!item)
             throw new MarAgentError('MAR_AGENT_MODEL_PROTOCOL_ERROR', 'Provider context item type is unsupported.');

package/dist/sdk/agent.js

@@ -3,7 +3,7 @@ import { isDeepStrictEqual } from 'node:util';
 import { describeMarAgentError, MarAgentError } from '../error.js';
 import { negotiateHost } from '../host/contracts.js';
 import { AnthropicMessagesAdapter, isAnthropicRecoverableStreamError } from '../model/anthropic-messages.js';
-import { resolveModelDefaultReasoningEffort } from '../model/configuration.js';
+import { marAgentReasoningEffortSchema, resolveModelDefaultReasoningEffort } from '../model/configuration.js';
 import { modelRetryMaxAttempts, isRetryableModelRequestError, waitForModelRetry } from '../model/http.js';
 import { OpenAiResponsesAdapter, isOpenAiResponsesRecoverableStreamError } from '../model/openai-responses.js';
 import { AsyncQueue } from '../runtime/async-queue.js';
@@ -400,6 +400,39 @@ export async function createMarAgent(options) {
                     let lastServerUsage = latestModelUsage(contextRecords, selectedModel.id);
                     const compactUserTokenLimit = Math.min(20_000, Math.floor(selectedModel.contextWindowTokens / 8));
                     const reasoningEffort = input.reasoningEffort ?? selectedModel.defaultReasoningEffort;
+                    const useEffortUpdates = selectedModel.protocol === 'OPENAI_RESPONSES' &&
+                        selectedModel.responsesEncoding !== 'LITE' &&
+                        selectedModel.codexCredential === true;
+                    const previousReasoningEffort = useEffortUpdates
+                        ? reasoningEffortBaseline(contextRecords, selectedModel.id)
+                        : undefined;
+                    let requestReasoningEffort = useEffortUpdates
+                        ? (previousReasoningEffort ?? reasoningEffort)
+                        : undefined;
+                    let effectiveReasoningEffort = useEffortUpdates
+                        ? previousReasoningEffort === undefined
+                            ? requestReasoningEffort
+                            : (lastConfigurationEffort(messages, selectedModel.id) ?? requestReasoningEffort)
+                        : undefined;
+                    if (mode !== 'compact' &&
+                        useEffortUpdates &&
+                        effectiveReasoningEffort !== reasoningEffort) {
+                        const update = {
+                            role: 'provider',
+                            content: '',
+                            provider: 'OPENAI_RESPONSES',
+                            providerModelId: selectedModel.id,
+                            item: { type: 'configuration_update', reasoning: { effort: reasoningEffort } }
+                        };
+                        messages.push(update);
+                        await store.append(sessionId, {
+                            type: 'model.context',
+                            payload: update,
+                            executionId,
+                            turnId
+                        });
+                        effectiveReasoningEffort = reasoningEffort;
+                    }
                     if (mode !== 'compact' && subagents)
                         await subagents.beginParentExecution({
                             executionId,
@@ -646,7 +679,7 @@ export async function createMarAgent(options) {
                                         tools: executionTools,
                                         toolChoice: 'none',
                                         promptCacheKey: sessionId,
-                                        reasoningEffort,
+                                        reasoningEffort: requestReasoningEffort ?? reasoningEffort,
                                         onAttemptDiagnostic: recordModelAttempt('COMPACTION')
                                     })) {
                                         if (event.type === 'text.completed' &&
@@ -713,6 +746,8 @@ export async function createMarAgent(options) {
                         await persistContextualWorldState(store, sessionId, contextualWorldState);
                         lastServerContextTokens = undefined;
                         lastServerUsage = undefined;
+                        requestReasoningEffort = reasoningEffort;
+                        effectiveReasoningEffort = reasoningEffort;
                         await emit({ type: 'context.compacted', compactionId });
                         return true;
                     };
@@ -796,6 +831,7 @@ export async function createMarAgent(options) {
                                         : { allowTools: false }),
                                 promptCacheKey: sessionId,
                                 reasoningEffort,
+                                ...(requestReasoningEffort === undefined ? {} : { requestReasoningEffort }),
                                 ...(modelInputImages?.length ? { images: modelInputImages } : {}),
                                 onAttemptDiagnostic: recordModelAttempt(mode === 'compact' ? 'COMPACTION' : 'EXECUTION')
                             })) {
@@ -1496,6 +1532,8 @@ function resolveAgentModels(configurations, requestedDefaultModelId) {
             (model.protocol !== 'OPENAI_RESPONSES' ||
                 !['STANDARD', 'LITE'].includes(model.responsesEncoding)))
             throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Responses encoding is invalid.');
+        if (model.fastMode === true && model.protocol !== 'OPENAI_RESPONSES')
+            throw new MarAgentError('MAR_AGENT_MODEL_CONFIG_INVALID', 'Fast mode requires Responses.');
         if (model.credentialProvider !== undefined)
             credentialProviders.add(model.credentialProvider);
     }
@@ -1754,6 +1792,38 @@ function latestModelUsage(records, selectedModelId) {
     }
     return usage;
 }
+function reasoningEffortBaseline(records, modelId) {
+    let baseline;
+    for (let index = records.length - 1; index >= 0; index--) {
+        const record = records[index];
+        if (compactSummaryFromCheckpoint(record) !== undefined)
+            break;
+        if (record.type !== 'execution.header')
+            continue;
+        const payload = record.payload;
+        if (payload.modelId !== modelId)
+            break;
+        const effort = marAgentReasoningEffortSchema.safeParse(payload.reasoningEffort);
+        if (effort.success)
+            baseline = effort.data;
+    }
+    return baseline;
+}
+function lastConfigurationEffort(messages, modelId) {
+    for (let index = messages.length - 1; index >= 0; index--) {
+        const message = messages[index];
+        if (message.role !== 'provider' ||
+            message.provider !== 'OPENAI_RESPONSES' ||
+            message.providerModelId !== modelId ||
+            message.item?.type !== 'configuration_update')
+            continue;
+        const reasoning = message.item.reasoning;
+        const effort = marAgentReasoningEffortSchema.safeParse(reasoning?.effort);
+        if (effort.success)
+            return effort.data;
+    }
+    return undefined;
+}
 function shouldUseNativeCompaction(input) {
     if (input.estimatedRequestTokens <= input.contextWindowTokens)
         return true;

package/package.json

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