@yu_robotics/remote-cli 1.6.173 → 1.6.177

package/dist/executor/CodexAppServerExecutor.js

@@ -123,6 +123,9 @@ class CodexAppServerExecutor {
     currentWorkingDirectory;
     model;
     effort;
+    speed;
+    /** Only a fresh legacy thread is known not to carry an older remote speed override. */
+    legacyFollowReady = false;
     reportedModel;
     reportedEffort;
     autoApprove;
@@ -166,6 +169,7 @@ class CodexAppServerExecutor {
     constructor(directoryGuard, options = {}) {
         this.directoryGuard = directoryGuard;
         this.model = options.model;
+        this.speed = options.speed;
         this.effort = options.effort;
         this.autoApprove = options.autoApprove ?? true;
         this.remoteThreadId = options.threadId;
@@ -224,6 +228,7 @@ class CodexAppServerExecutor {
             // leave the executor busy without an actual app-server turn.
             const sandboxOptions = this.sandbox.turnOptions(this.currentWorkingDirectory);
             const input = await this.buildInput(prompt, options.attachments, temporaryFiles);
+            const speedOptions = await this.speedOptions();
             if (this.isBusy()) {
                 await this.cleanupTemporaryFiles(temporaryFiles);
                 return { success: false, error: 'Codex thread is already running a command' };
@@ -256,6 +261,7 @@ class CodexAppServerExecutor {
                     cwd: this.currentWorkingDirectory,
                     ...(this.model ? { model: this.model } : {}),
                     ...(this.effort ? { effort: this.effort } : {}),
+                    ...speedOptions,
                     ...(this.autoApprove ? {
                         approvalPolicy: 'never',
                         sandboxPolicy: { type: 'dangerFullAccess' },
@@ -392,9 +398,14 @@ class CodexAppServerExecutor {
             return;
         // Native continuations bypass turn/start, so their settings must be sticky.
         const goalPolicy = this.sandbox.turnOptions(this.currentWorkingDirectory);
-        if (this.model || this.effort || Object.keys(goalPolicy).length) {
+        if (this.model || this.effort || this.speed !== undefined || Object.keys(goalPolicy).length) {
+            const speedOptions = await this.speedOptions();
+            this.assertGoalOwner(run);
+            if (run.controlling)
+                return;
             await this.goalRequest('thread/settings/update', { threadId: this.codexThreadId,
-                ...(this.model ? { model: this.model } : {}), ...(this.effort ? { effort: this.effort } : {}), ...goalPolicy });
+                ...(this.model ? { model: this.model } : {}), ...(this.effort ? { effort: this.effort } : {}),
+                ...speedOptions, ...goalPolicy });
             this.assertGoalOwner(run);
             if (run.controlling)
                 return;
@@ -860,15 +871,22 @@ class CodexAppServerExecutor {
     }
     async listModels() {
         await this.refreshModelCatalogAfterCommandUpgrade();
+        return this.readModelCatalog();
+    }
+    async readModelCatalog() {
         const models = [];
         let cursor = null;
         const currentModelId = this.reportedModel ?? this.model;
         do {
-            const response = await this.client.request('model/list', {
+            const owner = this.goalRun;
+            const params = {
                 cursor,
                 limit: 100,
                 includeHidden: false,
-            });
+            };
+            const response = await (owner ? this.goalRequest('model/list', params) : this.client.request('model/list', params));
+            if (owner)
+                this.assertGoalOwner(owner);
             for (const model of Array.isArray(response?.data) ? response.data : []) {
                 if (typeof model?.id !== 'string')
                     continue;
@@ -885,6 +903,11 @@ class CodexAppServerExecutor {
                         ? model.defaultReasoningEffort
                         : undefined,
                     inputModalities: Array.isArray(model.inputModalities) ? model.inputModalities : undefined,
+                    ...(Array.isArray(model.serviceTiers) && model.serviceTiers.length <= 32
+                        && model.serviceTiers.every((tier) => tier && this.validSpeedValue(tier.id) && this.validSpeedValue(tier.name)
+                            && (tier.description === undefined || (typeof tier.description === 'string' && tier.description.length <= 4096)))
+                        ? { serviceTiers: model.serviceTiers.map((tier) => ({ id: tier.id, name: tier.name, description: tier.description })),
+                            ...(model.defaultServiceTier === null || this.validSpeedValue(model.defaultServiceTier) ? { defaultServiceTier: model.defaultServiceTier } : {}) } : {}),
                 });
             }
             cursor = typeof response?.nextCursor === 'string' ? response.nextCursor : null;
@@ -937,6 +960,10 @@ class CodexAppServerExecutor {
             if (!selected) {
                 return { success: false, error: `Unknown Codex model: ${model}. Use /model to list available models.` };
             }
+            if (typeof this.speed === 'string' && (!selected.serviceTiers?.length
+                || (this.speed !== 'default' && !selected.serviceTiers.some(tier => tier.id === this.speed)))) {
+                return { success: false, error: 'The saved speed is incompatible with this model. Follow native config in the Speed section before changing models.' };
+            }
             if (this.effort && !selected.supportedReasoningEfforts?.includes(this.effort)) {
                 return { success: false, error: 'The saved reasoning effort is incompatible with this model. Reset /effort auto before changing models.' };
             }
@@ -950,10 +977,157 @@ class CodexAppServerExecutor {
         }
     }
     clearModel() {
+        if (typeof this.speed === 'string')
+            throw new Error('Follow native config in the Speed section before clearing the model override.');
         this.model = undefined;
         this.reportedModel = undefined;
         this.reportedEffort = undefined;
     }
+    validSpeedValue(value) {
+        return typeof value === 'string' && value.length > 0 && value.length <= 512 && !/[\x00-\x1f\x7f]/.test(value);
+    }
+    async listSpeeds(models) {
+        const catalog = models ?? await this.listModels();
+        const recovery = this.speed !== undefined ? { choices: [], current: this.speed ?? undefined } : undefined;
+        // Do not add config RPCs to legacy catalogs or to models with no tier choices.
+        if (!catalog.some(model => model.serviceTiers?.length))
+            return recovery;
+        let id = this.reportedModel ?? this.model;
+        if (!id) {
+            try {
+                id = (await this.readNativeSpeedConfig()).model;
+            }
+            catch (error) {
+                // A failed native query must not turn a catalog default into an offer of
+                // paid speed. A saved override can still be cleared without discovery.
+                if (recovery)
+                    return recovery;
+                throw error;
+            }
+        }
+        const selected = id ? catalog.find(model => model.id === id) : catalog.find(model => model.isDefault);
+        if (!selected?.serviceTiers?.length)
+            return recovery;
+        const choices = [{ value: 'default', displayName: 'Standard', description: 'Use standard processing.' },
+            ...selected.serviceTiers.filter(tier => tier.id !== 'default').map(tier => ({ value: tier.id, displayName: tier.name, description: tier.description }))];
+        return { choices, current: this.speed ?? undefined, default: selected.defaultServiceTier };
+    }
+    async assertReportedSpeed(speed) {
+        if (!this.reportedModel)
+            return;
+        const owner = this.goalRun;
+        const catalog = await (owner ? this.goalDeadline(this.readModelCatalog()) : this.readModelCatalog());
+        if (owner)
+            this.assertGoalOwner(owner);
+        const selected = catalog.find(model => model.id === this.reportedModel);
+        if (!selected?.serviceTiers?.length || (speed !== 'default' && !selected.serviceTiers.some(tier => tier.id === speed))) {
+            throw new Error('This speed is unavailable for the model reported by Codex. Follow native config in /model before starting work.');
+        }
+    }
+    async speedOptions(speed = this.speed) {
+        if (speed === undefined)
+            return {};
+        if (speed !== null)
+            return { serviceTier: speed };
+        // Avoid the public upgrade check while preparing a turn: replacing the
+        // transport here would discard the native thread just loaded by ensureThread.
+        const catalog = await this.readModelCatalog();
+        if (!catalog.some(model => model.serviceTiers !== undefined)) {
+            if (this.codexThreadId && !(this.threadReady && this.legacyFollowReady)) {
+                throw new Error('This Codex version cannot safely clear the speed of a saved conversation. Upgrade Codex or use /clear before resuming.');
+            }
+            // Old protocols must never receive unsupported serviceTier keys. A fresh
+            // thread can safely use native startup configuration without an override.
+            return {};
+        }
+        const config = await this.readNativeSpeedConfig();
+        const id = this.reportedModel ?? this.model ?? config.model;
+        const selected = id ? catalog.find(model => model.id === id) : catalog.find(model => model.isDefault);
+        if (config.tier === 'fast' || config.tier === 'priority') {
+            const fast = selected?.serviceTiers?.find(tier => tier.id === 'priority')
+                ?? selected?.serviceTiers?.find(tier => tier.id === 'fast');
+            return { serviceTier: config.fastMode && fast ? fast.id : null };
+        }
+        if (config.tier !== null && config.tier !== 'default' && config.tier !== 'flex'
+            && !selected?.serviceTiers?.some(tier => tier.id === config.tier)) {
+            throw new Error('Codex configured speed is unavailable for the selected model. Check native configuration before resuming.');
+        }
+        return { serviceTier: config.tier };
+    }
+    async readNativeSpeedConfig() {
+        const owner = this.goalRun;
+        const params = { includeLayers: false, cwd: this.currentWorkingDirectory };
+        const response = await (owner ? this.goalRequest('config/read', params) : this.client.request('config/read', params));
+        if (owner)
+            this.assertGoalOwner(owner);
+        if (!response?.config || typeof response.config !== 'object')
+            throw new Error('Codex did not provide its native speed configuration.');
+        const native = response.config.service_tier;
+        if (native !== undefined && native !== null && !this.validSpeedValue(native))
+            throw new Error('Codex returned an invalid native speed setting.');
+        const model = response.config.model;
+        if (model !== undefined && model !== null && !this.validSpeedValue(model))
+            throw new Error('Codex returned an invalid configured model.');
+        const features = response.config.features;
+        if (features !== undefined && (features === null || typeof features !== 'object' || Array.isArray(features)))
+            throw new Error('Codex returned invalid native speed features.');
+        const fastMode = features?.fast_mode;
+        if (fastMode !== undefined && typeof fastMode !== 'boolean')
+            throw new Error('Codex returned an invalid native Fast mode setting.');
+        return { model: model ?? undefined, tier: native ?? null, fastMode: fastMode !== false };
+    }
+    async setSpeed(speed) {
+        try {
+            const cwd = this.currentWorkingDirectory, threadId = this.codexThreadId;
+            const assertCurrent = () => {
+                if (this.isBusy() || this.destroyed || cwd !== this.currentWorkingDirectory || threadId !== this.codexThreadId)
+                    throw new Error('The Codex thread changed during speed selection.');
+            };
+            if (this.isBusy() || this.destroyed)
+                throw new Error('The Codex thread must be idle to change speed.');
+            if (speed === undefined) {
+                // Reset is recovery, not another selection. Never load a saved thread
+                // through its obsolete tier, nor resume suspended native goals here.
+                this.threadReady = false;
+                this.legacyFollowReady = false;
+                this.threadLoads++;
+                try {
+                    await this.client.stop();
+                    await this.client.waitForExit?.();
+                }
+                finally {
+                    this.threadLoads--;
+                }
+                assertCurrent();
+                this.speed = null;
+                return { success: true, output: 'Speed follows native configuration on the next safe resume. Older Codex versions may require an upgrade or /clear.' };
+            }
+            const choices = await this.listSpeeds();
+            assertCurrent();
+            if (!choices || !choices.choices.some(choice => choice.value === speed)) {
+                throw new Error('This speed is unavailable for the current Codex model. Refresh /model.');
+            }
+            if (this.isBusy() || this.destroyed)
+                throw new Error('The Codex thread changed during speed selection.');
+            if (this.codexThreadId && !(this.goalManaged && this.goalNeedsResume)) {
+                await this.ensureThread();
+                assertCurrent();
+                // Restored conversations can report a different model than the preview.
+                await this.assertReportedSpeed(speed);
+                assertCurrent();
+                // Explicit selections may update a live thread. Follow never loads it.
+                const { serviceTier } = await this.speedOptions(speed);
+                assertCurrent();
+                await this.client.request('thread/settings/update', { threadId: this.codexThreadId, serviceTier });
+                assertCurrent();
+            }
+            this.speed = speed;
+            return { success: true, output: 'Speed preference applied.' };
+        }
+        catch (error) {
+            return { success: false, error: this.errorMessage(error) };
+        }
+    }
     async listEfforts() {
         const models = await this.listModels();
         const currentModelId = this.reportedModel ?? this.model;
@@ -1081,14 +1255,28 @@ class CodexAppServerExecutor {
         }
         if (this.threadReady && this.client.isRunning())
             return;
+        this.threadReady = false;
+        this.legacyFollowReady = false;
         const goalOwner = this.goalRun;
         this.reportedModel = undefined;
         this.reportedEffort = undefined;
         await this.client.start();
+        if (goalOwner)
+            this.assertGoalOwner(goalOwner);
+        if (typeof this.speed === 'string') {
+            const available = await (goalOwner ? this.goalDeadline(this.listSpeeds()) : this.listSpeeds());
+            if (goalOwner)
+                this.assertGoalOwner(goalOwner);
+            if (!available?.choices.some(choice => choice.value === this.speed)) {
+                throw new Error('The saved speed is unavailable for this Codex model. Follow native config in /model before starting work.');
+            }
+        }
+        const speedOptions = await this.speedOptions();
         if (goalOwner)
             this.assertGoalOwner(goalOwner);
         const common = {
             ...(this.model ? { model: this.model } : {}),
+            ...speedOptions,
             cwd: this.currentWorkingDirectory,
             ...(this.autoApprove ? {
                 approvalPolicy: 'never',
@@ -1144,7 +1332,12 @@ class CodexAppServerExecutor {
                 throw new Error('Codex app-server returned no thread ID');
             this.captureReportedSettings(response);
             this.setThreadId(id);
+            this.legacyFollowReady = this.speed === null && !Object.prototype.hasOwnProperty.call(common, 'serviceTier');
         }
+        if (typeof this.speed === 'string')
+            await this.assertReportedSpeed(this.speed);
+        if (goalOwner)
+            this.assertGoalOwner(goalOwner);
         this.threadReady = true;
     }
     handleMessage(message) {