pi-freeflow 1.34.0 → 1.35.0

package/src/proxy.ts

@@ -28,6 +28,7 @@ import {
  PATH_TRAVERSAL_PATTERN,
  MAX_BODY_BYTES,
  PORT,
+ OVH_CHAT_URL,
  UPSTREAM_HEADER_TIMEOUT_MS,
  UPSTREAM_OPENCODE,
  opencodeHeaders,
@@ -41,14 +42,14 @@ import {
  type FindGlobRestore,
 } from "./opencode-fingerprint.ts";
 import { isDebugEnabled, log } from "./logger.ts";
-import { getModelUpstream, isClineModel, KILO_MODEL_IDS, MODEL_MAP, resolveCanonicalModelId } from "./models.ts";
+import { getModelUpstream, isClineModel, isOvhModel, KILO_MODEL_IDS, MODEL_MAP, ovhUpstreamModelId, resolveCanonicalModelId } from "./models.ts";
 import { ClineAuthError, refreshClineToken, toApiKey } from "./cline-device-auth.ts";
 import { rollChat } from "./cline-accounts.ts";
 import { fetchWithSystemCA } from "./system-ca-fetch.ts";
 import {
  chatResponsesJsonFromChatCompletion,
  chatResponsesSseFromChatCompletion,
- clineChatBodyFromResponsesBody,
+ chatBodyFromResponsesBody,
  translateToolsForPath,
 } from "./tool-translation.ts";
 import { buildArgRepairSchemas } from "./tool-args.ts";
@@ -261,7 +262,7 @@ async function handleClineRequest(opts: {
  const model = typeof parsedBody.model === "string" ? parsedBody.model : "unknown";
  let chatBody: Record<string, unknown>;
  if (responsesRequest) {
-  chatBody = clineChatBodyFromResponsesBody(parsedBody);
+  chatBody = chatBodyFromResponsesBody(parsedBody);
  } else {
   chatBody = { ...parsedBody };
   if (Array.isArray(chatBody.tools)) chatBody.tools = translateToolsForPath(chatBody.tools, "/v1/chat/completions");
@@ -384,12 +385,179 @@ async function handleClineRequest(opts: {
  }
 }
 
+/**
+ * Serve an OVH-model request direct (never relay pool, no opencode
+ * fingerprint). Chat-only upstream: OVH's responses endpoint rejects every
+ * array `input` shape with 422 "input: data did not match any variant of
+ * untagged enum ResponseInput" and accepts only a bare string (probed
+ * 2026-10-13), so a responses-path body translates to chat upstream and the
+ * chat answer translates back — the same shape mapping the Cline lane uses.
+ * Keyless: no Authorization header, because OVH answers anonymous callers.
+ * Upstream always streams; callers that asked for plain JSON get the
+ * aggregated object, and a streamed responses caller gets SSE re-emitted
+ * from the mapped Responses object.
+ */
+async function handleOvhRequest(opts: {
+ parsedBody: Record<string, unknown>;
+ pathname: string;
+ req: http.IncomingMessage;
+ res: http.ServerResponse;
+ reqId: string;
+ clientRequestedStream: boolean;
+}): Promise<void> {
+ const { parsedBody, pathname, req, res, reqId, clientRequestedStream } = opts;
+ const responsesRequest = pathname.endsWith("/responses");
+ const requestedModel = typeof parsedBody.model === "string" ? parsedBody.model : "unknown";
+ let chatBody: Record<string, unknown>;
+ if (responsesRequest) {
+  chatBody = chatBodyFromResponsesBody(parsedBody);
+ } else {
+  chatBody = { ...parsedBody };
+  if (Array.isArray(chatBody.tools)) chatBody.tools = translateToolsForPath(chatBody.tools, "/v1/chat/completions");
+  delete chatBody.prompt_cache_key;
+ }
+ // OVH knows only the bare id. Canonicalise before stripping: a short alias
+ // (`llama-3.3-70b`) must resolve to `ovh-free/Meta-Llama-3_3-70B-Instruct`
+ // first, or it reaches OVH unrecognised and answers 404 model_not_found.
+ chatBody.model = ovhUpstreamModelId(requestedModel);
+ // Bypassing the fingerprint does not exempt OVH from malformed tool
+ // arguments: capture the caller's own schemas before translation for repair.
+ const argSchemas = buildArgRepairSchemas(Array.isArray(parsedBody.tools) ? parsedBody.tools : []);
+ chatBody.stream = true;
+ // Header-wait timeout + client-disconnect abort, cleared once headers arrive
+ // so a long stream is not killed at the timeout ceiling.
+ const controller = new AbortController();
+ const timeoutId = setTimeout(
+  () => controller.abort(upstreamTimeoutError()),
+  UPSTREAM_HEADER_TIMEOUT_MS,
+ );
+ const abortOnClientGone = () => {
+  if (!res.writableEnded) controller.abort();
+ };
+ res.once("close", abortOnClientGone);
+ req.once("error", abortOnClientGone);
+ let upstreamRes: Response;
+ try {
+  // Keyless, direct (never the relay pool). OVH serves anonymous callers but
+  // rate-limits them, so a 429 here is a real per-IP cap and must NOT carry
+  // the relay-deploy hint — this lane can never ride a relay.
+  upstreamRes = await fetch(OVH_CHAT_URL, {
+   method: "POST",
+   headers: { "Content-Type": "application/json" },
+   body: JSON.stringify(chatBody),
+   signal: controller.signal,
+  });
+ } catch (e) {
+  log("error", "ovh upstream fetch failed", { error: String(e), model: requestedModel }, reqId);
+  if (!res.headersSent) {
+   res.writeHead(502, { "content-type": "application/json" });
+   res.end(JSON.stringify({ error: "upstream error" }));
+  } else if (!res.writableEnded) {
+   res.end();
+  }
+  return;
+ } finally {
+  clearTimeout(timeoutId);
+  res.off("close", abortOnClientGone);
+  req.off("error", abortOnClientGone);
+ }
+ if (res.writableEnded) {
+  try { await upstreamRes.body?.cancel(); } catch { }
+  return;
+ }
+ if (!upstreamRes.ok) {
+  log("warn", `ovh upstream ${upstreamRes.status} for model ${requestedModel}`, { status: upstreamRes.status, model: requestedModel }, reqId);
+  const raw = await upstreamRes.text().catch(() => null);
+  if (raw === null) {
+   log("error", "ovh upstream body unreadable", { status: upstreamRes.status, model: requestedModel }, reqId);
+   if (!res.headersSent) {
+    res.writeHead(502, { "content-type": "application/json" });
+    res.end(JSON.stringify({ error: "upstream error" }));
+   } else if (!res.writableEnded) {
+    res.end();
+   }
+   return;
+  }
+  if (!res.headersSent) {
+   res.writeHead(upstreamRes.status, { "content-type": upstreamRes.headers.get("content-type") || "application/json" });
+   res.end(raw);
+  } else if (!res.writableEnded) {
+   res.end();
+  }
+  return;
+ }
+ if (!responsesRequest && clientRequestedStream && upstreamRes.body) {
+  res.writeHead(upstreamRes.status, {
+   "content-type": upstreamRes.headers.get("content-type") || "text/event-stream",
+   "cache-control": "no-cache, no-transform",
+   connection: "keep-alive",
+   "x-accel-buffering": "no",
+  });
+  // Fetched direct, never through the relay pool: attributing an OVH-side
+  // stream failure to an unrelated relay would mark a healthy relay failed.
+  pipeUpstreamStream(
+   Readable.fromWeb(upstreamRes.body as unknown as WebReadableStream),
+   res,
+   req,
+   reqId,
+   "direct",
+   argSchemas.size > 0
+    ? { callerHadTools: true, argSchemas, pathname: "/v1/chat/completions" }
+    : undefined,
+  );
+  return;
+ }
+ const sseText = await upstreamRes.text().catch(() => null);
+ if (sseText === null) {
+  log("error", "ovh upstream stream unreadable", { status: upstreamRes.status, model: requestedModel }, reqId);
+  if (!res.headersSent) {
+   res.writeHead(502, { "content-type": "application/json" });
+   res.end(JSON.stringify({ error: "upstream error" }));
+  } else if (!res.writableEnded) {
+   res.end();
+  }
+  return;
+ }
+ if (!responsesRequest) {
+  const data = convertSseToJson(sseText, pathname, true, undefined, undefined, undefined, argSchemas);
+  if (!res.headersSent) {
+   res.writeHead(upstreamRes.status, { "content-type": "application/json" });
+   res.end(data);
+  } else if (!res.writableEnded) {
+   res.end();
+  }
+  return;
+ }
+ const chat = sseToChatCompletionJson(sseText, true, undefined, undefined, undefined, argSchemas);
+ const resp = chatResponsesJsonFromChatCompletion(chat, requestedModel);
+ if (clientRequestedStream) {
+  if (!res.headersSent) {
+   res.writeHead(200, {
+    "content-type": "text/event-stream",
+    "cache-control": "no-cache, no-transform",
+    connection: "keep-alive",
+    "x-accel-buffering": "no",
+   });
+   res.end(chatResponsesSseFromChatCompletion(resp));
+  } else if (!res.writableEnded) {
+   res.end();
+  }
+  return;
+ }
+ if (!res.headersSent) {
+  res.writeHead(200, { "content-type": "application/json" });
+  res.end(JSON.stringify(resp));
+ } else if (!res.writableEnded) {
+  res.end();
+ }
+}
+
 /**
  * Relay eligibility: only free-catalog models ride relay egress. Returns true
  * when the model is a non-empty string present in MODEL_MAP or KILO_MODEL_IDS
  * (Kilo traffic leaves via its own branch regardless), and when the model is
  * missing/empty (e.g. GET /v1/models carries no body — preserve routing).
- * Cline models are direct-only and never relay-eligible. Anything else
+ * Cline and OVH models are direct-only and never relay-eligible. Anything else
  * (unknown/paid model ids, non-strings) goes direct upstream.
  */
 export function isRelayEligibleModel(model: unknown): boolean {
@@ -397,7 +565,7 @@ export function isRelayEligibleModel(model: unknown): boolean {
  if (typeof model !== "string") return false;
  if (model.trim() === "") return true;
  const canonical = resolveCanonicalModelId(model.trim());
- if (isClineModel(canonical)) return false;
+ if (isClineModel(canonical) || isOvhModel(canonical)) return false;
  return MODEL_MAP.has(canonical) || KILO_MODEL_IDS.has(canonical) || isFreeCatalogId(canonical);
 }
 
@@ -935,7 +1103,7 @@ export function startProxy(
      id: m.id,
      object: "model",
      created: 0,
-     owned_by: m.source === "kilo" ? "kilocode" : m.source === "cline" ? "clinecode" : "opencode",
+     owned_by: m.source === "kilo" ? "kilocode" : m.source === "cline" ? "clinecode" : m.source === "ovh" ? "ovhcloud" : "opencode",
     })),
    });
    res.writeHead(200, {
@@ -1007,6 +1175,7 @@ export function startProxy(
    const bodyStr = Buffer.concat(bodyChunks).toString();
    let isKilo = false;
    let isCline = false;
+   let isOvh = false;
    let parsedBody: Record<string, unknown> | null = null;
    let clientRequestedStream = false;
 
@@ -1016,8 +1185,10 @@ export function startProxy(
      const canonical = resolveCanonicalModelId(parsedBody.model);
      if (isClineModel(canonical)) {
       isCline = true;
-     } else if (KILO_MODEL_IDS.has(canonical)) {
-      isKilo = true;
+    } else if (isOvhModel(canonical)) {
+     isOvh = true;
+    } else if (KILO_MODEL_IDS.has(canonical)) {
+     isKilo = true;
      }
     }
     if (parsedBody && typeof parsedBody === "object") {
@@ -1055,7 +1226,7 @@ export function startProxy(
    let callerFindGlob: FindGlobRestore | undefined;
   let callerInjected: string[] | undefined;
   let callerArgSchemas: Map<string, Record<string, unknown>> | undefined;
-   if (!isKilo && !isCline && parsedBody) {
+   if (!isKilo && !isCline && !isOvh && parsedBody) {
     const fp = enforceOpencodeFingerprint(parsedBody, target.pathname);
     callerHadTools = fp.callerHadTools;
     callerCaseRestore = fp.caseRestore;
@@ -1066,8 +1237,8 @@ export function startProxy(
    }
    // Streaming cloak: thread this request's placeholder records into the SSE
    // pipe so streamed deltas get the same strip+restore as aggregated bodies.
-   // Kilo/Cline bypass the fingerprint, so their streams stay verbatim.
-   const streamCloak: StreamCloakOptions | undefined = !isKilo && !isCline && callerInjected !== undefined
+   // Kilo/Cline/OVH bypass the fingerprint, so their streams stay verbatim.
+   const streamCloak: StreamCloakOptions | undefined = !isKilo && !isCline && !isOvh && callerInjected !== undefined
     ? { callerHadTools, caseRestore: callerCaseRestore, findGlob: callerFindGlob, injected: callerInjected, argSchemas: callerArgSchemas, pathname: target.pathname }
     : undefined;
 
@@ -1078,7 +1249,7 @@ export function startProxy(
    // anthropic-messages models reach /v1/messages. A request on the wrong path
    // means the host still holds a pre-fix provider registration (stale disk
    // cache or no restart after upgrade) and upstream answers 500.
-   if (!isKilo && !isCline && typeof parsedBody?.model === "string") {
+   if (!isKilo && !isCline && !isOvh && typeof parsedBody?.model === "string") {
     const knownDef = MODEL_MAP.get(String(parsedBody.model));
     if (target.pathname.endsWith("/chat/completions") && knownDef?.api && knownDef.api !== "openai-completions") {
      log("warn", `model ${String(parsedBody.model)} expects ${knownDef.api} but got ${target.pathname} — stale provider registration (restart Pi/OMP after upgrade)`, { model: String(parsedBody.model), path: target.pathname }, reqId);
@@ -1218,7 +1389,11 @@ export function startProxy(
       res.writeHead(response.status, { "content-type": ct });
       res.end(data);
      }
-    } else {
+   } else if (isOvh && parsedBody) {
+    // OVH serves chat upstream only (see handleOvhRequest): direct, keyless,
+    // no fingerprint, and a responses-path body translated to chat and back.
+    await handleOvhRequest({ parsedBody, pathname: target.pathname, req, res, reqId, clientRequestedStream });
+   } else {
      // OpenCode routing — relay egress is for free-catalog models
      // only; unknown/paid models go direct upstream.
      const relayState = getActiveRelayState();

package/src/tool-translation.ts

@@ -332,31 +332,100 @@ export function upstreamToolNameFor(name: string): string {
  return isFindToolName(name) ? "glob" : name.trim();
 }
 /**
- * Restore record for the find->glob rename. True only when the caller sent
- * `find` (any case) without also sending `glob`: the single upstream `glob`
- * unambiguously stands for the caller `find`. When the caller sent both,
- * upstream collapses to one `glob` (first-seen wins) and no restore applies.
+ * Restore records for the upstream-name rewrites: `find`->`glob` and the
+ * sanitization of names upstream rejects. `renamed` maps every rewritten
+ * upstream name (lowercased) back to the caller's original, so an emitted
+ * call still resolves to the tool the caller actually registered.
+ *
+ * `renamedFindToGlob` is true only when the caller sent `find` (any case)
+ * without also sending `glob`: the single upstream `glob` unambiguously stands
+ * for the caller `find`. When the caller sent both, upstream collapses to one
+ * `glob` (first-seen wins) and no single-name restore applies.
  */
 export interface FindGlobRestore {
- renamedFindToGlob: boolean;
+	renamedFindToGlob: boolean;
+	/** Sanitized upstream name (lowercased) -> caller name. Absent when every
+	 * caller name was already upstream-legal, so nothing was rewritten. */
+	renamed?: Record<string, string>;
+}
+
+/**
+ * Upstream accepts only `^[a-zA-Z0-9_.-]+$` as a tool name and answers
+ * `400 \`name\` must match` otherwise. Hosts do send such names — measured in
+ * live Pi sessions: `TG drive` (space), `env:production` (colon) — so the
+ * whole request dies on one badly named tool.
+ *
+ * Every character outside the allowed set folds to `_`, and a collision with
+ * an already-emitted name gets a numeric suffix. The caller name is recorded
+ * so `restoreToolNameForCaller` puts it back; the model never sees a name it
+ * cannot match against its own earlier call. A name that already matches is
+ * returned unchanged, so well-formed tool sets are untouched.
+ */
+const UPSTREAM_NAME_SHAPE = /^[a-zA-Z0-9_.-]+$/;
+
+/**
+ * Fold one caller tool name to a shape upstream accepts. Deterministic, and a
+ * pure function of the name: the same input always sanitizes to the same
+ * output, which is what lets the caller name be recovered downstream.
+ */
+export function sanitizeUpstreamToolName(name: string, taken: ReadonlySet<string>): string {
+	const trimmed = name.trim();
+	if (UPSTREAM_NAME_SHAPE.test(trimmed)) return trimmed;
+	let folded = trimmed.replace(/[^a-zA-Z0-9_.-]/g, "_");
+	// A name made entirely of invalid characters would sanitize to a leading
+	// run of underscores and collide with every other such name; anchor it.
+	if (folded.length === 0) folded = "tool";
+	let candidate = folded;
+	let n = 2;
+	while (taken.has(candidate.toLowerCase())) {
+		candidate = `${folded}_${n}`;
+		n += 1;
+	}
+	return candidate;
 }
-/** Inspect the original caller tools (pre-translate) for the find->glob case. */
+/** Inspect the original caller tools (pre-translate) for the rewrite cases. */
 export function buildFindGlobRestore(callerTools: unknown[]): FindGlobRestore {
- let sawFind = false;
- let sawGlob = false;
- for (const tool of callerTools) {
-  const canon = canonicalizeTool(tool);
-  if (!canon) continue;
-  if (isFindToolName(canon.name)) sawFind = true;
-  else if (canon.name.trim().toLowerCase() === "glob") sawGlob = true;
-  if (sawFind && sawGlob) break;
- }
- return { renamedFindToGlob: sawFind && !sawGlob };
+	let sawFind = false;
+	let sawGlob = false;
+	const renamed: Record<string, string> = {};
+	// Same first-seen-wins order and case rules as translateToolsForPath, so
+	// the recorded map keys match the names that actually reach upstream.
+	const seen = new Set<string>();
+	for (const tool of callerTools) {
+		const canon = canonicalizeTool(tool);
+		if (!canon) continue;
+		const callerName = canon.name;
+		if (isFindToolName(callerName)) sawFind = true;
+		else if (callerName.trim().toLowerCase() === "glob") sawGlob = true;
+		// Mirrors translateToolsForPath: dedup on the lowercased
+		// pre-sanitization name (a collapsed duplicate never reaches upstream),
+		// then sanitize with the caller's casing intact.
+		const dedupKey = upstreamToolNameFor(callerName).toLowerCase();
+		if (seen.has(dedupKey)) continue;
+		seen.add(dedupKey);
+		const sanitized = sanitizeUpstreamToolName(upstreamToolNameFor(callerName), seen);
+		if (sanitized.toLowerCase() !== dedupKey) seen.add(sanitized.toLowerCase());
+		// Only character-folding rewrites belong in the sanitized map. The
+		// find->glob rename is a collision case with its own flag: when the
+		// caller also sent `glob`, upstream `glob` really is the caller's glob,
+		// so recording it here would misroute a genuine call.
+		if (sanitized !== callerName && !isFindToolName(callerName)) {
+			renamed[sanitized.toLowerCase()] = callerName;
+		}
+	}
+	const restored: FindGlobRestore = { renamedFindToGlob: sawFind && !sawGlob, renamed };
+	return restored;
 }
-/** Downstream name: map the upstream `glob` back to caller `find` when renamed. */
+/**
+ * Downstream name: undo the upstream rewrites. The sanitized map is checked
+ * first because it is keyed by the exact name upstream saw; the find->glob
+ * case stays as the single-name fallback.
+ */
 export function restoreToolNameForCaller(name: string, restore: FindGlobRestore): string {
- if (restore.renamedFindToGlob && name.trim().toLowerCase() === "glob") return "find";
- return name;
+	const sanitized = restore.renamed?.[name.trim().toLowerCase()];
+	if (sanitized !== undefined) return sanitized;
+	if (restore.renamedFindToGlob && name.trim().toLowerCase() === "glob") return "find";
+	return name;
 }
 function retargetChoice(value: unknown, from: string, to: string): unknown {
  if (typeof value === "string") {
@@ -447,18 +516,25 @@ export function translateToolsForPath(tools: unknown[], pathname: string): Recor
    out.push(rec);
    continue;
   }
-  const upstreamName = upstreamToolNameFor(canon.name);
-  const key = upstreamName.toLowerCase();
-  if (seen.has(key)) continue;
-  seen.add(key);
-  const needsRename = upstreamName !== canon.name;
-  if (!needsRename && alreadyTargetShape(rec, api)) {
-   out.push(rec);
-   continue;
-  }
-  const renamed: CanonicalTool = needsRename
-   ? { ...canon, name: upstreamName }
-   : canon;
+ // Duplicate collapse stays first-seen-wins on the lowercased upstream name
+ // (`Bash` never duplicates `bash`, `find` collapses with `glob`) and runs on
+ // the pre-sanitization name: the emitted name keeps the caller's casing, and
+ // the sanitizer only ever folds characters the upstream shape forbids.
+ const dedupKey = upstreamToolNameFor(canon.name).toLowerCase();
+ if (seen.has(dedupKey)) continue;
+ seen.add(dedupKey);
+ // The find->glob rename and the name sanitization share one upstream name,
+ // so a caller tool needing either is emitted under a single new name.
+ const upstreamName = sanitizeUpstreamToolName(upstreamToolNameFor(canon.name), seen);
+ if (upstreamName.toLowerCase() !== dedupKey) seen.add(upstreamName.toLowerCase());
+ const needsRename = upstreamName !== canon.name;
+ if (!needsRename && alreadyTargetShape(rec, api)) {
+  out.push(rec);
+  continue;
+ }
+ const renamed: CanonicalTool = needsRename
+  ? { ...canon, name: upstreamName }
+  : canon;
   const converted =
    api === "responses"
     ? toResponsesTool(renamed)
@@ -584,8 +660,11 @@ export function responsesInputToChatMessages(input: unknown): Record<string, unk
  * instructions (as the leading system message), input, tools (reshaped to
  * chat via translateToolsForPath), tool_choice, and plain sampling scalars.
  * Stream policy stays with the caller: this maps shape, never behavior.
+ *
+ * Lane-neutral: used by every direct-only lane that serves chat upstream and
+ * answers a responses-path caller (Cline, OVHcloud AI Endpoints).
  */
-export function clineChatBodyFromResponsesBody(body: Record<string, unknown>): Record<string, unknown> {
+export function chatBodyFromResponsesBody(body: Record<string, unknown>): Record<string, unknown> {
  const out: Record<string, unknown> = {};
  if (typeof body.model === "string") out.model = body.model;
  const messages: Record<string, unknown>[] = [];
@@ -657,7 +736,7 @@ export function chatResponsesJsonFromChatCompletion(chat: Record<string, unknown
 /**
  * Wrap a Responses object in the minimal valid Responses SSE sequence
  * (created + completed + DONE) so streamed responses-path clients get a
- * stream even though Cline only serves chat upstream. Round-trips through
+ * stream even though the upstream lane only serves chat. Round-trips through
  * sseToResponsesJson: the completed event carries the full object.
  */
 export function chatResponsesSseFromChatCompletion(resp: Record<string, unknown>): string {