ldrouter 1.17.0 → 1.17.2

package/CHANGELOG.md

@@ -4,6 +4,24 @@ All notable changes to this project are documented here. The format follows
 [Keep a Changelog](https://keepachangelog.com/) and the project adheres to
 [Semantic Versioning](https://semver.org/).
 
+## [1.17.2] - 2026-09-17
+
+### Fixed
+
+- **Every second message to a `codex/` model failed with `502 Codex upstream HTTP 400`.** The Responses `input` array was built with one content block type for all roles: assistant history went upstream as `input_text`, which the backend rejects ("Invalid value: 'input_text'. Supported values are: 'output_text' and 'refusal'"). The first message of a conversation worked because it carries no assistant turn; every follow-up carries the previous answer, so chat, combo and agent traffic died from the second turn onward. Assistant prose is now sent as `output_text`. Verified live against chatgpt.com with a two-turn conversation (both turns 200).
+- **Tool history was rejected the same way.** `function_call` and `function_call_output` are top-level `input` items on the Responses API, never content blocks — a call nested in `content` answers `400 invalid_value` listing the permitted block types. Tool calls and their results are now emitted as flat items correlated by `call_id`.
+- **`Codex upstream HTTP 400` said nothing about the cause.** The upstream error body, which names the offending field (`param input[i].content[j]`), was discarded. It is now included in the thrown message, secret-redacted and truncated.
+
+## [1.17.1] - 2026-09-17
+
+### Added
+
+- **Combo members are ordered by drag and drop.** The combo create/edit dialog lists members as sortable rows (`@dnd-kit`, the same interaction as the Codex and Qoder account pools): drag the handle — or reorder with the keyboard — and the row order becomes the saved priority, `position` 0 being tried first in fallback mode and leading the rotation in weighted round-robin.
+
+### Fixed
+
+- **`GET /api/admin/combos/:id` returned members in SQLite row order instead of priority order**, so a reordered combo could reopen showing the previous sequence. Members are now sorted by `position`.
+
 ## [1.17.0] - 2026-09-17
 
 ### Added

package/dist/server/providers/codex.js

@@ -1,4 +1,5 @@
 import { withCodexCredentials, refreshCodexAccount } from './codex-refresh.js';
+import { redactString, redactValue } from '../security/redact.js';
 const base = (url) => url.replace(/\/$/, '');
 /**
  * Reported Codex CLI client version. The models endpoint rejects requests without it:
@@ -75,13 +76,7 @@ export async function codexModels(cfg) {
  */
 const CODEX_REQUIRED_FLAGS = { store: false, stream: true };
 export function codexRequestPayload(req, targetModel = req.model) {
-    const input = req.messages.map((message) => ({ role: message.role, content: message.content.map((block) => {
-            if (block.type === 'text')
-                return { type: 'input_text', text: block.text ?? '' };
-            if (block.type === 'image' && (block.image?.url || block.image?.base64))
-                return { type: 'input_image', image_url: block.image?.url ?? `data:${block.image?.mimeType ?? 'image/png'};base64,${block.image?.base64}` };
-            return null;
-        }).filter(Boolean) }));
+    const input = codexInputItems(req.messages);
     const payload = { model: targetModel, input, ...CODEX_REQUIRED_FLAGS };
     if (req.system)
         payload.instructions = req.system;
@@ -94,6 +89,64 @@ export function codexRequestPayload(req, targetModel = req.model) {
         payload.reasoning = { effort: req.reasoning.effort };
     return payload;
 }
+/**
+ * Translate canonical messages into the Responses `input` array.
+ *
+ * The backend is strict about which item shapes are legal and rejects the rest
+ * with `400 invalid_value`, naming the offending `input[i]` path:
+ *  - a text block on an assistant turn must be `output_text`; `input_text` is
+ *    rejected ("Invalid value: 'input_text'. Supported values are: 'output_text'
+ *    and 'refusal'"). So a plain chat follow-up — history contains an assistant
+ *    turn — failed while the first message of a conversation worked.
+ *  - tool calls and their results are NOT content blocks: a `function_call`
+ *    inside `content` is rejected ("Supported values are: 'input_text',
+ *    'input_image', …"). They are top-level items, `function_call` and
+ *    `function_call_output`, correlated by `call_id`.
+ * Verified live against chatgpt.com.
+ */
+export function codexInputItems(messages) {
+    const items = [];
+    for (const message of messages) {
+        const content = [];
+        const flushMessage = () => {
+            if (content.length > 0)
+                items.push({ role: message.role, content: [...content] });
+            content.length = 0;
+        };
+        for (const block of message.content) {
+            if (block.type === 'text') {
+                // Assistant prose is "output" from the API's point of view; everything else is input.
+                content.push(message.role === 'assistant' ? { type: 'output_text', text: block.text ?? '' } : { type: 'input_text', text: block.text ?? '' });
+                continue;
+            }
+            if (block.type === 'image' && (block.image?.url || block.image?.base64)) {
+                content.push({ type: 'input_image', image_url: block.image?.url ?? `data:${block.image?.mimeType ?? 'image/png'};base64,${block.image?.base64}` });
+                continue;
+            }
+            if (block.type === 'tool_use' && block.toolUse) {
+                // Top-level item, so the message wrapping the call is emitted first.
+                flushMessage();
+                items.push({
+                    type: 'function_call',
+                    call_id: block.toolUse.id,
+                    name: block.toolUse.name,
+                    arguments: typeof block.toolUse.input === 'string' ? block.toolUse.input : JSON.stringify(block.toolUse.input ?? {}),
+                });
+                continue;
+            }
+            if (block.type === 'tool_result' && block.toolResult) {
+                flushMessage();
+                items.push({
+                    type: 'function_call_output',
+                    call_id: block.toolResult.toolUseId,
+                    output: typeof block.toolResult.content === 'string' ? block.toolResult.content : JSON.stringify(block.toolResult.content ?? ''),
+                });
+            }
+        }
+        flushMessage();
+    }
+    return items;
+}
 function usage(value) {
     const u = (value && typeof value === 'object' ? value : {});
     const input = typeof u.input_tokens === 'number' ? u.input_tokens : 0;
@@ -146,7 +199,20 @@ export function codexStreamEventToCanonical(event) {
     return { text: '', isLast: false };
 }
 async function responseError(response) {
-    const error = Object.assign(new Error(`Codex upstream HTTP ${response.status}`), { status: response.status });
+    // The backend explains every rejection (`{"error":{"message":"Invalid value: ...","param":"input[1].content[0]"}}`).
+    // Without it an operator only sees "HTTP 400" and has to re-derive the cause by hand.
+    let detail = '';
+    try {
+        const parsed = JSON.parse(await response.text());
+        const message = typeof parsed.error?.message === 'string' ? parsed.error.message : typeof parsed.detail === 'string' ? parsed.detail : null;
+        // redactValue, not just redactString: an error body can echo a secret under a
+        // secret-named key, which only the structured pass recognizes.
+        detail = message
+            ? `: ${message}${typeof parsed.error?.param === 'string' ? ` (param ${parsed.error.param})` : ''}`
+            : `: ${JSON.stringify(redactValue(parsed))}`;
+    }
+    catch { /* a non-JSON or already-read body must not mask the status */ }
+    const error = Object.assign(new Error(`Codex upstream HTTP ${response.status}${redactString(detail).slice(0, 500)}`), { status: response.status });
     return error;
 }
 export async function callCodexNonStreaming(cfg, req) {
@@ -172,8 +238,11 @@ export async function callCodexStreaming(cfg, req, onEvent) {
         const ctl = timeout(tokenCfg.totalTimeoutMs);
         try {
             const response = await fetch(codexRequest(tokenCfg, '/responses'), { method: 'POST', headers: codexHeaders(tokenCfg, 'text/event-stream'), body: JSON.stringify(codexRequestPayload(req)), signal: ctl.signal });
-            if (!response.ok || !response.body)
+            // Only a failed response is read as text here; a 2xx with no body must still report its status.
+            if (!response.ok)
                 throw await responseError(response);
+            if (!response.body)
+                throw Object.assign(new Error(`Codex upstream HTTP ${response.status}: empty response body`), { status: response.status });
             const reader = response.body.getReader();
             const decoder = new TextDecoder();
             let buffer = '';

package/dist/server/routes/admin/combos.js

@@ -118,7 +118,10 @@ export async function registerComboRoutes(app) {
         const c = db.select().from(schema.combos).where(eq(schema.combos.id, id)).get();
         if (!c)
             throw new GatewayError('invalid_request_error', 'Combo not found', { status: 404 });
-        const members = db.select().from(schema.comboMembers).where(eq(schema.comboMembers.comboId, id)).all();
+        // The admin UI shows (and drag-reorders) members by priority, so return them
+        // in position order rather than relying on SQLite row order.
+        const members = db.select().from(schema.comboMembers).where(eq(schema.comboMembers.comboId, id)).all()
+            .sort((a, b) => a.position - b.position);
         const models = db.select().from(schema.models).all();
         const modelMap = new Map(models.map((m) => [m.id, m]));
         return {