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: allow Codex render concurrency above ten

[._.]/ Adam Eivy84a9bdacd699
diff --git a/client/src/components/settings/ImageGenTab.jsx b/client/src/components/settings/ImageGenTab.jsx
index 5052e47e0c..88c829e546 100644
--- a/client/src/components/settings/ImageGenTab.jsx
+++ b/client/src/components/settings/ImageGenTab.jsx
@@ -37,6 +37,7 @@ import { useAgyModels } from '../../hooks/useAgyModels';
import { useHfTokenStatus } from '../../hooks/useHfTokenStatus';
import useLocalImageModels from '../../hooks/useLocalImageModels';
import { effortLevelsForProvider, isCodexSubscriptionProvider, providerModelList } from '../../utils/providers';
+import { formatCount } from '../../utils/formatters';
const SDAPI_TOOL_ID = 'sdapi';
const CODEX_TOOL_ID = 'codex-imagegen';
@@ -50,7 +51,7 @@ const normalizeUrl = (url) => (url || '').trim().replace(/\/+$/, '');
// Fallback bounds used until /api/settings has been fetched once. The server
// is the source of truth (returns `imageGen.codex.parallelLimitBounds` with
// the real min/max/default), so these only matter for the first paint.
-const PARALLEL_FALLBACK = { min: 1, max: 10, default: 1 };
+const PARALLEL_FALLBACK = { min: 1, max: Number.MAX_SAFE_INTEGER, default: 1 };
const clampParallel = (n, bounds = PARALLEL_FALLBACK) =>
Math.max(bounds.min, Math.min(bounds.max, Math.floor(Number(n) || bounds.default)));
@@ -1363,12 +1364,11 @@ export function ImageGenTab() {
className="w-24 bg-port-bg border border-port-border rounded-lg px-3 py-2 text-sm text-white focus:outline-none focus:border-port-accent"
/>
<p className="text-xs text-gray-500 mt-1">
- How many Codex renders the queue runs in parallel. Default <code>{parallelBounds.default}</code>. Hard capped at <code>{parallelBounds.max}</code>.
- Higher values let large batches finish faster but burn OpenAI credits non-linearly — a runaway {parallelBounds.max}-wide
- batch can rack up real money in minutes.
- {codexParallelLimit > Math.ceil(parallelBounds.max / 2) && (
+ How many Codex renders the queue runs in parallel. Default <code>{formatCount(parallelBounds.default)}</code>.
+ Higher values let large batches finish faster, subject to your provider&apos;s rate limits, and increase simultaneous usage.
+ {codexParallelLimit > 5 && (
<span className="block mt-1 text-port-warning">
- ⚠️ {codexParallelLimit} concurrent renders can burn credits quickly during a long batch. Watch usage.
+ ⚠️ {formatCount(codexParallelLimit)} concurrent renders can burn credits quickly during a long batch. Watch usage.
</span>
)}
</p>
diff --git a/client/src/components/settings/ImageGenTab.test.jsx b/client/src/components/settings/ImageGenTab.test.jsx
index f9f65290e5..5205232235 100644
--- a/client/src/components/settings/ImageGenTab.test.jsx
+++ b/client/src/components/settings/ImageGenTab.test.jsx
@@ -94,6 +94,25 @@ beforeEach(() => {
});
describe('ImageGenTab grouped tabs', () => {
+ it.each([undefined, { min: 1, max: Number.MAX_SAFE_INTEGER, default: 1 }])(
+ 'loads and saves render limits above ten with bounds %j', async (parallelLimitBounds) => {
+ getSettings.mockResolvedValue({
+ imageGen: {
+ mode: 'codex', codex: { enabled: true, parallelLimit: 25, parallelLimitBounds },
+ },
+ });
+ await renderTab(['/media/image?mediaTab=codex']);
+ const input = screen.getByLabelText('Parallel render limit');
+ expect(input.value).toBe('25');
+ fireEvent.change(input, { target: { value: '50' } });
+ fireEvent.blur(input);
+ expect(input.value).toBe('50');
+ fireEvent.click(screen.getByRole('button', { name: /^Save$/ }));
+ await waitFor(() => expect(updateSettings).toHaveBeenCalled());
+ expect(updateSettings.mock.calls[0][0].imageGen.codex.parallelLimit).toBe(50);
+ },
+ );
+
it('renders a pills sub-nav with all media-settings groups', async () => {
await renderTab();
const tabs = screen.getAllByRole('tab').map((t) => t.textContent);
diff --git a/server/services/imageGenEvents.js b/server/services/imageGenEvents.js
index 61de5d1267..1c7beda51b 100644
--- a/server/services/imageGenEvents.js
+++ b/server/services/imageGenEvents.js
@@ -3,15 +3,11 @@ import { EventEmitter } from 'events';
import { makeEmitterFaultIsolating } from '../lib/faultIsolatedEmitter.js';
export const imageGenEvents = makeEmitterFaultIsolating(new EventEmitter());
-// Each in-flight image job attaches ~6 listeners (progress/status/completed/
-// failed + 2 watchdog activity tracers). With CODEX_PARALLEL_MAX = 10 codex
-// renders in flight plus a concurrent local image render, that's 60+ live
-// listeners — well past Node's default cap of 10. Setting it to 0 disables
-// the leak warning entirely; the listener pairs are deterministically detached
-// in runJob's terminate() + final detach() so a real leak would surface as
-// memory growth in pm2 status, not as the warning. 200 leaves headroom for
-// short overlap during job churn.
-imageGenEvents.setMaxListeners(200);
+// Each in-flight image job attaches progress/status/completion listeners and
+// watchdog activity tracers. Cloud concurrency is user-configured, so no fixed
+// listener threshold distinguishes a large batch from a leak. runJob detaches
+// each job's listeners on termination and again in its final cleanup.
+imageGenEvents.setMaxListeners(0);
// Async completion listeners own their leases instead of borrowing the provider's.
const emit = imageGenEvents.emit;
diff --git a/server/services/mediaJobQueue/index.js b/server/services/mediaJobQueue/index.js
index 19b0a95661..4b2755bcbd 100644
--- a/server/services/mediaJobQueue/index.js
+++ b/server/services/mediaJobQueue/index.js
@@ -272,7 +272,8 @@ const videoHolds = createVideoHolds();
export const REMOTE_MEDIA_PARALLEL_LIMIT = 20;
export const CODEX_PARALLEL_MIN = 1;
-export const CODEX_PARALLEL_MAX = 10;
+// Keep counts exactly representable without imposing a provider throughput cap.
+export const CODEX_PARALLEL_MAX = Number.MAX_SAFE_INTEGER;
export const CODEX_PARALLEL_DEFAULT = 1;
let codexParallelLimit = CODEX_PARALLEL_DEFAULT;
const clampParallel = (n) => {
diff --git a/server/services/mediaJobQueue/index.test.js b/server/services/mediaJobQueue/index.test.js
index e55467d93f..42fdd198da 100644
--- a/server/services/mediaJobQueue/index.test.js
+++ b/server/services/mediaJobQueue/index.test.js
@@ -1890,6 +1890,33 @@ describe('Audio kind (#1928)', () => {
});
describe('Codex lane', () => {
+ it('runs more than ten renders while enforcing the saved limit and cleaning up listeners', async () => {
+ // Kickoff resolves; terminal events keep each render active until completed.
+ stubs.generateImageCodex.mockResolvedValue({});
+ await mediaJobQueue.initMediaJobQueue();
+ mediaJobQueue.setCodexParallelLimit(12);
+ const events = ['progress', 'status', 'completed', 'failed'];
+ const listenerCounts = () => events.map((event) => imageGenEvents.listenerCount(event));
+ const before = listenerCounts();
+ const jobs = [];
+ for (let i = 0; i < 13; i++) {
+ jobs.push(await mediaJobQueue.enqueueJob({
+ kind: 'image', params: { prompt: `Example render ${i}`, mode: 'codex' },
+ }));
+ }
+ await waitFor(() => stubs.generateImageCodex.mock.calls.length === 12);
+ expect(mediaJobQueue.getQueueCapacity().lanes.cloud.limit).toBe(12);
+ expect(mediaJobQueue.getJob(jobs[12].jobId).status).toBe('queued');
+
+ imageGenEvents.emit('completed', { generationId: jobs[0].jobId, filename: 'example.png' });
+ await waitFor(() => stubs.generateImageCodex.mock.calls.length === 13);
+ for (const job of jobs.slice(1)) {
+ imageGenEvents.emit('completed', { generationId: job.jobId, filename: 'example.png' });
+ }
+ await waitFor(() => jobs.every((job) => mediaJobQueue.getJob(job.jobId).status === 'completed'));
+ expect(listenerCounts()).toEqual(before);
+ });
+
it('dispatches a Codex job to imageGen/codex.js#generateImage, not local', async () => {
// Allow the codex job to resolve immediately so the worker can settle.
stubs.generateImageCodex.mockResolvedValue({ jobId: 'whatever' });