@fudrouter/fsrouter 0.6.63 → 0.6.64

package/open-sse/executors/vertex.js

@@ -1,131 +0,0 @@
-import { BaseExecutor } from "./base.js";
-import { PROVIDERS } from "../config/providers.js";
-import { parseVertexSaJson, refreshVertexToken } from "../services/tokenRefresh.js";
-import { proxyAwareFetch } from "../utils/proxyFetch.js";
-
-// Cache project IDs resolved from raw API keys { apiKey → projectId }
-const projectIdCache = new Map();
-
-/**
- * Resolve GCP project ID from a raw Vertex API key.
- * Sends a dummy 404 request and parses "projects/{id}" from the error message.
- */
-async function resolveProjectId(apiKey) {
-  if (projectIdCache.has(apiKey)) return projectIdCache.get(apiKey);
-
-  const res = await fetch(
-    `https://aiplatform.googleapis.com/v1/publishers/google/models/__probe__:generateContent?key=${apiKey}`,
-    { method: "POST", headers: { "Content-Type": "application/json" }, body: "{}" }
-  );
-  const json = await res.json().catch(() => null);
-  const msg = json?.[0]?.error?.message || json?.error?.message || "";
-  const match = msg.match(/projects\/([^/]+)\//);
-  const projectId = match?.[1] || null;
-
-  if (projectId) projectIdCache.set(apiKey, projectId);
-  return projectId;
-}
-
-/**
- * VertexExecutor - Google Cloud Vertex AI
- *
- * "vertex"         → Gemini models via regional/global Vertex endpoint
- * "vertex-partner" → Partner models (Llama, Mistral, GLM, DeepSeek, Qwen)
- *                    via global OpenAI-compatible endpoint
- *
- * Auth: SA JSON (stored as apiKey) → JWT assertion → Bearer token (via jose)
- * Token is minted/cached in tokenRefresh.js, not here.
- */
-export class VertexExecutor extends BaseExecutor {
-  constructor(providerId = "vertex") {
-    super(providerId, PROVIDERS[providerId] || {});
-  }
-
-  buildUrl(model, stream, urlIndex = 0, credentials = null) {
-    const saJson = parseVertexSaJson(credentials?.apiKey);
-    const rawKey = !saJson ? credentials?.apiKey : null;
-    const projectId = saJson?.project_id || credentials?.providerSpecificData?.projectId;
-
-    if (this.provider === "vertex-partner") {
-      // Partner models require project_id in path regardless of auth method
-      if (!projectId) throw new Error("Vertex partner models require a project_id. Add it in providerSpecificData or use Service Account JSON.");
-      const url = `https://aiplatform.googleapis.com/v1/projects/${projectId}/locations/global/endpoints/openapi/chat/completions`;
-      return rawKey ? `${url}?key=${rawKey}` : url;
-    }
-
-    // Gemini on Vertex
-    const action = stream ? "streamGenerateContent" : "generateContent";
-
-    if (saJson) {
-      // SA JSON + Bearer token: must use project-scoped path to avoid RESOURCE_PROJECT_INVALID
-      const location = credentials?.providerSpecificData?.location || "us-central1";
-      let url = `https://aiplatform.googleapis.com/v1/projects/${projectId}/locations/${location}/publishers/google/models/${model}:${action}`;
-      if (stream) url += "?alt=sse";
-      return url;
-    }
-
-    // Raw API key: use global publishers endpoint with ?key= param
-    // ?alt=sse is required for proper SSE streaming (matches every other Gemini executor)
-    let url = `https://aiplatform.googleapis.com/v1/publishers/google/models/${model}:${action}`;
-    if (stream) url += "?alt=sse";
-    if (rawKey) url += stream ? `&key=${rawKey}` : `?key=${rawKey}`;
-    return url;
-  }
-
-  buildHeaders(credentials, stream = true) {
-    const headers = { "Content-Type": "application/json" };
-
-    // Only set Bearer token if using SA JSON flow (raw key goes in URL ?key=)
-    if (credentials.accessToken) {
-      headers["Authorization"] = `Bearer ${credentials.accessToken}`;
-    }
-
-    if (stream) headers["Accept"] = "text/event-stream";
-
-    return headers;
-  }
-
-  async refreshCredentials(credentials, log) {
-    const saJson = parseVertexSaJson(credentials?.apiKey);
-    if (!saJson) return null;
-
-    const result = await refreshVertexToken(saJson, log);
-    if (!result) return null;
-
-    return { accessToken: result.accessToken, expiresAt: result.expiresAt };
-  }
-
-  async execute({ model, body, stream, credentials, signal, log, proxyOptions = null }) {
-    const saJson = parseVertexSaJson(credentials?.apiKey);
-
-    // SA JSON flow: mint Bearer token (cached)
-    if (saJson) {
-      const result = await refreshVertexToken(saJson, log);
-      if (!result?.accessToken) throw new Error("Vertex: failed to mint access token from Service Account JSON");
-      credentials.accessToken = result.accessToken;
-    }
-
-    // vertex-partner with raw key: auto-resolve project_id if not provided
-    if (this.provider === "vertex-partner" && !saJson && !credentials?.providerSpecificData?.projectId) {
-      const projectId = await resolveProjectId(credentials.apiKey);
-      if (!projectId) throw new Error("Vertex: could not resolve project_id from API key. Please add it manually in provider settings.");
-      log?.debug?.("VERTEX", `Resolved project_id: ${projectId}`);
-      credentials.providerSpecificData = { ...credentials.providerSpecificData, projectId };
-    }
-
-    const url = this.buildUrl(model, stream, 0, credentials);
-    const headers = this.buildHeaders(credentials, stream);
-    const transformedBody = this.transformRequest(model, body, stream, credentials);
-
-    const response = await proxyAwareFetch(url, {
-      method: "POST",
-      headers,
-      body: JSON.stringify(transformedBody),
-      signal,
-    }, proxyOptions);
-
-    return { response, url, headers, transformedBody };
-  }
-}
-
-export default VertexExecutor;

package/open-sse/executors/vertexMedia.js

@@ -1,236 +0,0 @@
-import { Buffer } from "node:buffer";
-import { sleep } from "../utils/sleep.ts";
-import {
-  parseSAFromApiKey,
-  getAccessToken,
-  looksLikeServiceAccountJson,
-  isExpressApiKey
-} from "./vertex.ts";
-const DEFAULT_REGION = "us-central1";
-function resolveRegion(credentials) {
-  const psd = credentials?.providerSpecificData;
-  if (psd && typeof psd === "object") {
-    const region = psd.region;
-    if (typeof region === "string" && region.trim().length > 0) return region.trim();
-  }
-  return DEFAULT_REGION;
-}
-async function resolveVertexAuth(credentials) {
-  const apiKey = typeof credentials?.apiKey === "string" ? credentials.apiKey.trim() : "";
-  const region = resolveRegion(credentials);
-  let bearerToken = typeof credentials?.accessToken === "string" && credentials.accessToken.trim().length > 0 ? credentials.accessToken.trim() : null;
-  let project = "";
-  let expressKey = null;
-  if (looksLikeServiceAccountJson(apiKey)) {
-    const sa = parseSAFromApiKey(apiKey);
-    project = typeof sa.project_id === "string" ? sa.project_id : "";
-    if (!bearerToken) bearerToken = await getAccessToken(sa);
-  } else if (isExpressApiKey(apiKey)) {
-    expressKey = apiKey;
-  }
-  return { project, region, bearerToken, expressKey };
-}
-function buildModelRequest(auth, model, action) {
-  const headers = { "Content-Type": "application/json" };
-  if (auth.bearerToken && auth.project) {
-    headers["Authorization"] = `Bearer ${auth.bearerToken}`;
-    return {
-      url: `https://${auth.region}-aiplatform.googleapis.com/v1/projects/${auth.project}/locations/${auth.region}/publishers/google/models/${model}:${action}`,
-      headers
-    };
-  }
-  if (auth.expressKey) {
-    return {
-      url: `https://aiplatform.googleapis.com/v1/publishers/google/models/${model}:${action}?key=${encodeURIComponent(
-        auth.expressKey
-      )}`,
-      headers
-    };
-  }
-  throw new Error(
-    "Vertex AI requires a Service Account JSON (with project_id) or a Vertex AI Express API key"
-  );
-}
-async function vertexError(res) {
-  let detail = "";
-  try {
-    detail = await res.text();
-  } catch {
-  }
-  let message = `Vertex AI error (${res.status})`;
-  if (detail) {
-    try {
-      const parsed = JSON.parse(detail);
-      message = parsed?.error?.message || message;
-    } catch {
-      message = detail.slice(0, 300);
-    }
-  }
-  const err = new Error(message);
-  err.status = res.status;
-  return err;
-}
-function pcmToWav(pcm, sampleRate = 24e3, channels = 1, bitsPerSample = 16) {
-  const blockAlign = channels * bitsPerSample / 8;
-  const byteRate = sampleRate * blockAlign;
-  const header = Buffer.alloc(44);
-  header.write("RIFF", 0);
-  header.writeUInt32LE(36 + pcm.length, 4);
-  header.write("WAVE", 8);
-  header.write("fmt ", 12);
-  header.writeUInt32LE(16, 16);
-  header.writeUInt16LE(1, 20);
-  header.writeUInt16LE(channels, 22);
-  header.writeUInt32LE(sampleRate, 24);
-  header.writeUInt32LE(byteRate, 28);
-  header.writeUInt16LE(blockAlign, 32);
-  header.writeUInt16LE(bitsPerSample, 34);
-  header.write("data", 36);
-  header.writeUInt32LE(pcm.length, 40);
-  return Buffer.concat([header, pcm]);
-}
-function parseSampleRate(mimeType) {
-  if (!mimeType) return 24e3;
-  const match = /rate=(\d+)/i.exec(mimeType);
-  return match ? parseInt(match[1], 10) : 24e3;
-}
-function extractInlineAudio(data) {
-  const parts = data?.candidates?.[0]?.content?.parts;
-  if (!Array.isArray(parts)) return null;
-  for (const part of parts) {
-    const inline = part?.inlineData;
-    if (inline && typeof inline.data === "string" && inline.data.length > 0) {
-      return {
-        base64: inline.data,
-        mimeType: typeof inline.mimeType === "string" ? inline.mimeType : "audio/L16;rate=24000"
-      };
-    }
-  }
-  return null;
-}
-function extractText(data) {
-  const parts = data?.candidates?.[0]?.content?.parts;
-  if (!Array.isArray(parts)) return "";
-  return parts.map((part) => part?.text).filter((text) => typeof text === "string").join("").trim();
-}
-async function vertexGenerateSpeech(credentials, options) {
-  const auth = await resolveVertexAuth(credentials);
-  const { url, headers } = buildModelRequest(auth, options.model, "generateContent");
-  const payload = {
-    contents: [{ role: "user", parts: [{ text: options.input }] }],
-    generationConfig: {
-      responseModalities: ["AUDIO"],
-      speechConfig: {
-        voiceConfig: {
-          prebuiltVoiceConfig: { voiceName: options.voice && options.voice.trim() ? options.voice.trim() : "Kore" }
-        }
-      }
-    }
-  };
-  const res = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
-  if (!res.ok) throw await vertexError(res);
-  const data = await res.json();
-  const inline = extractInlineAudio(data);
-  if (!inline) throw new Error("Vertex TTS returned no audio content");
-  const pcm = Buffer.from(inline.base64, "base64");
-  return { audio: pcmToWav(pcm, parseSampleRate(inline.mimeType)), contentType: "audio/wav" };
-}
-async function vertexTranscribe(credentials, options) {
-  const auth = await resolveVertexAuth(credentials);
-  const { url, headers } = buildModelRequest(auth, options.model, "generateContent");
-  const instruction = options.prompt && options.prompt.trim().length > 0 ? options.prompt.trim() : `Transcribe this audio verbatim. Output only the spoken words${options.language ? ` (language: ${options.language})` : ""}, with no commentary.`;
-  const payload = {
-    contents: [
-      {
-        role: "user",
-        parts: [
-          { text: instruction },
-          { inlineData: { mimeType: options.mimeType || "audio/wav", data: options.audioBase64 } }
-        ]
-      }
-    ]
-  };
-  const res = await fetch(url, { method: "POST", headers, body: JSON.stringify(payload) });
-  if (!res.ok) throw await vertexError(res);
-  return extractText(await res.json());
-}
-async function vertexGenerateMusic(credentials, options) {
-  const auth = await resolveVertexAuth(credentials);
-  const model = options.model && options.model.trim() ? options.model.trim() : "lyria-002";
-  const { url, headers } = buildModelRequest(auth, model, "predict");
-  const instance = { prompt: options.prompt };
-  if (options.negativePrompt) instance.negative_prompt = options.negativePrompt;
-  if (typeof options.seed === "number") instance.seed = options.seed;
-  const parameters = {};
-  if (typeof options.sampleCount === "number") parameters.sample_count = options.sampleCount;
-  const res = await fetch(url, {
-    method: "POST",
-    headers,
-    body: JSON.stringify({ instances: [instance], parameters })
-  });
-  if (!res.ok) throw await vertexError(res);
-  const data = await res.json();
-  const base64 = data?.predictions?.[0]?.bytesBase64Encoded;
-  if (typeof base64 !== "string" || base64.length === 0) {
-    throw new Error("Vertex Lyria returned no audio");
-  }
-  return { base64, format: "wav" };
-}
-async function vertexGenerateVideo(credentials, options) {
-  const auth = await resolveVertexAuth(credentials);
-  const submit = buildModelRequest(auth, options.model, "predictLongRunning");
-  const instance = { prompt: options.prompt };
-  if (options.image) instance.image = options.image;
-  const parameters = {
-    sampleCount: typeof options.sampleCount === "number" ? options.sampleCount : 1
-  };
-  if (options.aspectRatio) parameters.aspectRatio = options.aspectRatio;
-  if (typeof options.durationSeconds === "number") parameters.durationSeconds = options.durationSeconds;
-  if (options.negativePrompt) parameters.negativePrompt = options.negativePrompt;
-  const submitRes = await fetch(submit.url, {
-    method: "POST",
-    headers: submit.headers,
-    body: JSON.stringify({ instances: [instance], parameters })
-  });
-  if (!submitRes.ok) throw await vertexError(submitRes);
-  const op = await submitRes.json();
-  const operationName = op?.name;
-  if (typeof operationName !== "string" || operationName.length === 0) {
-    throw new Error("Vertex Veo did not return an operation name");
-  }
-  const poll = buildModelRequest(auth, options.model, "fetchPredictOperation");
-  const intervalMs = options.pollIntervalMs && options.pollIntervalMs > 0 ? options.pollIntervalMs : 1e4;
-  const maxWaitMs = options.maxWaitMs && options.maxWaitMs > 0 ? options.maxWaitMs : 5 * 60 * 1e3;
-  const deadline = Date.now() + maxWaitMs;
-  while (Date.now() < deadline) {
-    await sleep(intervalMs);
-    const pollRes = await fetch(poll.url, {
-      method: "POST",
-      headers: poll.headers,
-      body: JSON.stringify({ operationName })
-    });
-    if (!pollRes.ok) throw await vertexError(pollRes);
-    const pollData = await pollRes.json();
-    if (pollData?.done) {
-      const opError = pollData?.error;
-      if (opError) throw new Error(String(opError.message || "Veo operation failed"));
-      const videos = pollData?.response?.videos;
-      const video = Array.isArray(videos) ? videos[0] : null;
-      if (video && typeof video.bytesBase64Encoded === "string") {
-        return { base64: video.bytesBase64Encoded, format: "mp4" };
-      }
-      if (video && typeof video.gcsUri === "string") {
-        return { url: video.gcsUri, format: "mp4" };
-      }
-      throw new Error("Veo operation completed but returned no video");
-    }
-  }
-  throw new Error("Vertex Veo video generation timed out");
-}
-export {
-  pcmToWav,
-  vertexGenerateMusic,
-  vertexGenerateSpeech,
-  vertexGenerateVideo,
-  vertexTranscribe
-};