fix(providers): strip redundant node prefix on connId-addressed custom models (#6772)

changelog.d/fixes/6772-6772-connid-model-400.md

@@ -0,0 +1 @@
+- fix(providers): strip redundant node prefix when resolving custom OpenAI/Anthropic-compatible connections by raw connection id, preventing double-namespaced model ids from 400ing upstream (#6772)

src/sse/services/model.ts

@@ -85,6 +85,22 @@ async function lookupCustomModelMeta(
   }
 }
 
+/**
+ * When a custom provider node is matched by its raw internal `node.id` (e.g. a combo
+ * step addressing `<connId>/...` — see #2778), `parsed.model` was never split on the
+ * node's own `prefix`, unlike the alias-addressing path where `parseModel` already
+ * strips it. If the caller naively concatenates `owned_by` (the node's prefix, as
+ * listed by /api/models) with the raw model id, the resulting model string carries a
+ * redundant leading `${node.prefix}/` segment that the upstream provider does not
+ * recognize, causing a 400. Strip it so `<connId>/<prefix>/<rawModelId>` normalizes to
+ * the same `<rawModelId>` the bare alias form resolves to (#6772).
+ */
+function stripRedundantNodePrefix(model: string, nodePrefix: unknown): string {
+  if (typeof nodePrefix !== "string" || !nodePrefix) return model;
+  const redundant = `${nodePrefix}/`;
+  return model.startsWith(redundant) ? model.slice(redundant.length) : model;
+}
+
 /**
  * Get full model info (parse or resolve)
  */
@@ -133,13 +149,17 @@ export async function getModelInfo(modelStr) {
         (node) => node.prefix === prefixToCheck || node.id === prefixToCheck
       );
       if (matchedOpenAI) {
+        const normalizedModel = stripRedundantNodePrefix(
+          parsed.model as string,
+          matchedOpenAI.prefix
+        );
         const { apiFormat, targetFormat } = await lookupCustomModelMeta(
           matchedOpenAI.id as string,
-          parsed.model as string
+          normalizedModel
         );
         return {
           provider: matchedOpenAI.id,
-          model: parsed.model,
+          model: normalizedModel,
           extendedContext,
           ...(apiFormat && { apiFormat }),
           ...(targetFormat && { targetFormat }),
@@ -152,13 +172,17 @@ export async function getModelInfo(modelStr) {
         (node) => node.prefix === prefixToCheck || node.id === prefixToCheck
       );
       if (matchedAnthropic) {
+        const normalizedModel = stripRedundantNodePrefix(
+          parsed.model as string,
+          matchedAnthropic.prefix
+        );
         const { apiFormat, targetFormat } = await lookupCustomModelMeta(
           matchedAnthropic.id as string,
-          parsed.model as string
+          normalizedModel
         );
         return {
           provider: matchedAnthropic.id,
-          model: parsed.model,
+          model: normalizedModel,
           extendedContext,
           ...(apiFormat && { apiFormat }),
           ...(targetFormat && { targetFormat }),

tests/unit/model-connid-prefix-normalization-6772.test.ts

@@ -0,0 +1,86 @@
+/**
+ * PROBE for issue #6772 — custom OpenAI-compat <connId>/<listedModelId> 400s when the
+ * connection has a user-defined `prefix` and the listed model id (from /api/models)
+ * already carries that prefix baked in ("fta/vova/gpt-5.5").
+ *
+ * Root cause hypothesis: in src/sse/services/model.ts getModelInfo(), when a client
+ * addresses the connection by its raw internal node id (`<connId>/...`), the matching
+ * branch finds the node via `node.id === prefixToCheck` but returns `parsed.model`
+ * UNSTRIPPED of the node's own `prefix` — so `<connId>/<prefix>/<rawModelId>` resolves
+ * to `{ provider: connId, model: "<prefix>/<rawModelId>" }` instead of stripping the
+ * redundant prefix down to the actual registered custom model id `<rawModelId>`.
+ */
+import test from "node:test";
+import assert from "node:assert/strict";
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const TEST_DATA_DIR = fs.mkdtempSync(path.join(os.tmpdir(), "omniroute-probe-6772-"));
+process.env.DATA_DIR = TEST_DATA_DIR;
+
+const core = await import("../../src/lib/db/core.ts");
+const providersDb = await import("../../src/lib/db/providers.ts");
+const modelsDb = await import("../../src/lib/db/models.ts");
+const { getModelInfo } = await import("../../src/sse/services/model.ts");
+
+const CONN_ID = "openai-compatible-chat-97b0e595-probe6772";
+const PREFIX = "fta";
+const RAW_MODEL_ID = "vova/gpt-5.5"; // upstream's own model id already has a slash
+
+test.before(async () => {
+  await providersDb.createProviderNode({
+    id: CONN_ID,
+    type: "openai-compatible",
+    name: "freetheai (probe)",
+    prefix: PREFIX,
+    baseUrl: "https://proxy.example.com",
+    chatPath: "/v1/chat/completions",
+    modelsPath: "/v1/models",
+  });
+  await modelsDb.addCustomModel(
+    CONN_ID,
+    RAW_MODEL_ID,
+    "vova gpt-5.5",
+    "manual",
+    "chat-completions",
+    ["chat"]
+  );
+});
+
+test.after(() => {
+  core.resetDbInstance();
+  fs.rmSync(TEST_DATA_DIR, { recursive: true, force: true });
+});
+
+test("#6772 baseline: bare alias form `fta/vova/gpt-5.5` resolves to the raw model id", async () => {
+  const info = (await getModelInfo(`${PREFIX}/${RAW_MODEL_ID}`)) as {
+    provider?: string;
+    model?: string;
+  };
+  assert.equal(info.provider, CONN_ID, "must resolve to the custom node via its prefix");
+  assert.equal(info.model, RAW_MODEL_ID, "model must be the raw registered custom model id");
+});
+
+test("#6772 baseline: `<connId>/vova/gpt-5.5` (no namespace) resolves to the raw model id", async () => {
+  const info = (await getModelInfo(`${CONN_ID}/${RAW_MODEL_ID}`)) as {
+    provider?: string;
+    model?: string;
+  };
+  assert.equal(info.provider, CONN_ID, "must resolve to the custom node via its internal id");
+  assert.equal(info.model, RAW_MODEL_ID, "model must be the raw registered custom model id");
+});
+
+test("#6772 RED: `<connId>/<prefix>/<rawModelId>` (naive owned_by+id concat) must normalize to the raw model id, not double-prefix", async () => {
+  const info = (await getModelInfo(`${CONN_ID}/${PREFIX}/${RAW_MODEL_ID}`)) as {
+    provider?: string;
+    model?: string;
+  };
+  assert.equal(info.provider, CONN_ID, "must resolve to the custom node via its internal id");
+  assert.equal(
+    info.model,
+    RAW_MODEL_ID,
+    `model must strip the node's own prefix "${PREFIX}/" so it matches the registered custom model id ` +
+      `"${RAW_MODEL_ID}" — got "${info.model}" instead (double-namespaced, will 400 upstream)`
+  );
+});