Skip to content

Self-hosted, Self-Improving, Federated Everything App — dev management, agent orchestration, persistent mind, digital twin, second brain, and creative pipeline from a single dashboard over Tailscale to port the user into the OS

fix: honor selected models in manual CLI runs

Adam Eivy6ed840d9719a
diff --git a/server/lib/aiToolkit/routes/runs.js b/server/lib/aiToolkit/routes/runs.js
index 2768beccb8..d75ad95a45 100644
--- a/server/lib/aiToolkit/routes/runs.js
+++ b/server/lib/aiToolkit/routes/runs.js
@@ -88,19 +88,26 @@ export function createRunsRoutes(runnerService, options = {}) {
const runModel = runData.usedFallback
? (runData.fallbackModel || provider.defaultModel || null)
: model;
- // executeCliRun reads `provider.defaultModel` for `--model` injection, so a
- // fallback pin must be threaded in via a clone (mirrors the TUI branch and
- // promptRunner's `providerForRun`). Only on the fallback path — non-fallback
- // CLI runs keep their existing behavior of using the provider's own default
- // (the request `model` has never been threaded into CLI runs here).
- const cliProvider = (runData.usedFallback && runModel && runModel !== provider.defaultModel)
+ // CLI/TUI executors read defaultModel for their argv and run-started hooks.
+ // Pin the requested (or fallback) model without changing the saved provider.
+ const executionProvider = (runModel && runModel !== provider.defaultModel)
? { ...provider, defaultModel: runModel }
: provider;
+ // Gateway credentials are attached non-enumerably on provider reads. A
+ // spread drops them; retain that execution-only key without exposing it to
+ // JSON serialization or persistence (same contract as the host prompt runner).
+ if (executionProvider !== provider && !executionProvider.apiKey && provider.apiKey) {
+ Object.defineProperty(executionProvider, 'apiKey', {
+ value: provider.apiKey,
+ enumerable: false,
+ configurable: true,
+ });
+ }
if (provider.type === 'cli') {
void Promise.resolve(runnerService.executeCliRun({
runId,
- provider: cliProvider,
+ provider: executionProvider,
prompt,
workspacePath,
onData: (data) => {
@@ -135,18 +142,9 @@ export function createRunsRoutes(runnerService, options = {}) {
io?.emit(`run:${runId}:complete`, { id: runId, success: false, error: error.message });
});
} else if (provider.type === 'tui' && typeof runnerService.executeTuiRun === 'function') {
- // Honor the user-picked model from the Runs UI — `executeTuiRun` reads
- // `provider.defaultModel` for its `--model` injection, so without the
- // clone every TUI run would silently fall back to the provider's saved
- // default even when the user picked something else. Uses `runModel` so a
- // fallback swap runs the fallback's model rather than leaking the
- // primary's request model onto the fallback.
- const effectiveProvider = runModel
- ? { ...provider, defaultModel: runModel }
- : provider;
void Promise.resolve(runnerService.executeTuiRun({
runId,
- provider: effectiveProvider,
+ provider: executionProvider,
prompt,
workspacePath,
onData: (data) => {
diff --git a/server/lib/aiToolkit/routes/runs.test.js b/server/lib/aiToolkit/routes/runs.test.js
index 19654ea038..a19f214f59 100644
--- a/server/lib/aiToolkit/routes/runs.test.js
+++ b/server/lib/aiToolkit/routes/runs.test.js
@@ -3,6 +3,7 @@ import express from 'express';
import { request } from '../../testHelper.js';
import { createRunsRoutes } from './runs.js';
import { asyncHandler as portosAsyncHandler, errorMiddleware, ServerError } from '../../errorHandler.js';
+import { buildCliArgs } from '../../cliProviderArgs.js';
// Route-level harness for POST /api/runs fallback-model execution.
//
@@ -49,15 +50,15 @@ function runData({ providerType, defaultModel, usedFallback = false, fallbackMod
// Sends BOTH workspace fields, as the real client does — a name without a path
// means "app selected but its Repository Path is unset" and is now a 400 (see
// the selected-app-without-a-path suite at the bottom of this file).
-const post = (app) =>
+const post = (app, overrides = {}) =>
request(app)
.post('/api/runs')
- .send({ providerId: 'p1', model: REQUEST_MODEL, prompt: 'hello', workspaceName: 'ws', workspacePath: '/srv/repos/ws' });
+ .send({ providerId: 'p1', model: REQUEST_MODEL, prompt: 'hello', workspaceName: 'ws', workspacePath: '/srv/repos/ws', ...overrides });
-describe('POST /api/runs — fallback-model execution', () => {
+describe('POST /api/runs — model execution', () => {
beforeEach(() => vi.clearAllMocks());
- describe('(a) non-fallback runs honor the request model where the type threads it', () => {
+ describe('(a) non-fallback runs honor the request model', () => {
it('API: passes the request model as the 3rd executeApiRun arg', async () => {
const { app, runnerService } = makeApp(
runData({ providerType: 'api', defaultModel: 'provider-default' })
@@ -80,17 +81,56 @@ describe('POST /api/runs — fallback-model execution', () => {
expect(runnerService.executeTuiRun.mock.calls[0][0].provider.defaultModel).toBe(REQUEST_MODEL);
});
- it('CLI: leaves the provider untouched (request model is never threaded into CLI runs)', async () => {
- const provider = runData({ providerType: 'cli', defaultModel: 'provider-default' });
- const { app, runnerService } = makeApp(provider);
+ it('CLI: executes the requested model while preserving the saved default', async () => {
+ const run = runData({ providerType: 'cli', defaultModel: 'provider-default' });
+ Object.assign(run.provider, { id: 'claude-code', command: 'claude', args: [] });
+ const { app, runnerService } = makeApp(run);
const res = await post(app);
expect(res.status).toBe(202);
expect(runnerService.executeCliRun).toHaveBeenCalledTimes(1);
- // executeCliRun({ runId, provider: cliProvider, prompt, ... }): no clone, keeps provider's own default
const cliProvider = runnerService.executeCliRun.mock.calls[0][0].provider;
- expect(cliProvider).toBe(provider.provider);
+ expect(buildCliArgs(cliProvider)).toEqual(['-p', '-', '--model', REQUEST_MODEL]);
+ expect(cliProvider).not.toBe(run.provider);
+ expect(run.provider.defaultModel).toBe('provider-default');
+ });
+
+ it('CLI: retains the configured default when the request omits a model', async () => {
+ const run = runData({ providerType: 'cli', defaultModel: 'provider-default' });
+ const { app, runnerService } = makeApp(run);
+ const res = await post(app, { model: undefined });
+ expect(res.status).toBe(202);
+ const cliProvider = runnerService.executeCliRun.mock.calls[0][0].provider;
+ expect(cliProvider).toBe(run.provider);
expect(cliProvider.defaultModel).toBe('provider-default');
});
+
+ it('CLI: preserves the configured argv model pin when selecting a model', async () => {
+ const run = runData({ providerType: 'cli', defaultModel: 'provider-default' });
+ Object.assign(run.provider, { id: 'claude-code', command: 'claude', args: ['--model', 'configured-pin'] });
+ const { app, runnerService } = makeApp(run);
+ const res = await post(app);
+ expect(res.status).toBe(202);
+ const cliProvider = runnerService.executeCliRun.mock.calls[0][0].provider;
+ expect(buildCliArgs(cliProvider)).toEqual(['--model', 'configured-pin', '-p', '-']);
+ });
+ });
+
+ it.each([
+ ['cli', false, null, REQUEST_MODEL],
+ ['tui', true, 'fallback-pinned', 'fallback-pinned'],
+ ])('%s: model overrides preserve execution-only gateway credentials', async (providerType, usedFallback, fallbackModel, expectedModel) => {
+ const run = runData({ providerType, defaultModel: 'provider-default', usedFallback, fallbackModel });
+ Object.defineProperty(run.provider, 'apiKey', { value: 'synthetic-gateway-key', enumerable: false, configurable: true });
+ const { app, runnerService } = makeApp(run);
+ const res = await post(app);
+ expect(res.status).toBe(202);
+ const execute = providerType === 'cli' ? runnerService.executeCliRun : runnerService.executeTuiRun;
+ const executionProvider = execute.mock.calls[0][0].provider;
+ expect(executionProvider.defaultModel).toBe(expectedModel);
+ expect(executionProvider.apiKey).toBe('synthetic-gateway-key');
+ expect(Object.getOwnPropertyDescriptor(executionProvider, 'apiKey').enumerable).toBe(false);
+ expect(JSON.stringify(executionProvider)).not.toContain('synthetic-gateway-key');
+ expect(run.provider.defaultModel).toBe('provider-default');
});
describe('(b) fallback swap with a configured fallbackModel runs that pinned model', () => {
@@ -136,7 +176,7 @@ describe('POST /api/runs — fallback-model execution', () => {
expect(runnerService.executeApiRun.mock.calls[0][0].model).not.toBe(REQUEST_MODEL);
});
- it('TUI: clones the fallback provider with its own default, never the request model', async () => {
+ it('TUI: uses the fallback provider with its own default, never the request model', async () => {
const { app, runnerService } = makeApp(
runData({ providerType: 'tui', defaultModel: FALLBACK_DEFAULT, usedFallback: true, fallbackModel: null })
);