@myagentroam/agent 0.9.109 → 0.9.110

package/dist/cli/main.js

@@ -383,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;
@@ -35,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;

package/dist/model/configuration.d.ts

@@ -91,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/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';
@@ -887,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' } : {})
         }
@@ -1616,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));
@@ -1626,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')
                             })) {
@@ -1756,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.109",
+  "version": "0.9.110",
   "description": "Embeddable MAR coding agent SDK and CLI.",
   "license": "Apache-2.0",
   "type": "module",