veryfront 0.1.215 → 0.1.217

package/src/src/provider/runtime-loader.ts

@@ -1,5 +1,24 @@
-import * as dntShim from "../../_dnt.shims.js";
 import type { EmbeddingRuntime, ModelRuntime } from "./types.js";
+import {
+  getAnthropicMessagesUrl,
+  getGoogleEmbeddingUrl,
+  getGoogleGenerateContentUrl,
+  getGoogleStreamGenerateContentUrl,
+  getOpenAIChatCompletionsUrl,
+  getOpenAIEmbeddingUrl,
+  getOpenAIResponsesUrl,
+} from "./runtime-loader/provider-endpoints.js";
+import {
+  createAnthropicRequestInit,
+  createGoogleRequestInit,
+  createOpenAIRequestInit,
+} from "./runtime-loader/provider-request-init.js";
+import {
+  TOOL_INPUT_PENDING_THRESHOLD_MS,
+  withToolInputStatusTransitions,
+} from "./runtime-loader/tool-input-status.js";
+
+export { TOOL_INPUT_PENDING_THRESHOLD_MS, withToolInputStatusTransitions };
 
 export interface OpenAIRuntimeConfig {
   apiKey: string;
@@ -301,6 +320,7 @@ type OpenAICompatibleChatRequest = {
     include_usage?: boolean;
   };
   max_tokens?: number;
+  max_completion_tokens?: number;
   temperature?: number;
   top_p?: number;
   stop?: string[];
@@ -377,252 +397,6 @@ type GoogleCompatibleRequest = {
   [key: string]: unknown;
 };
 
-const DEFAULT_ANTHROPIC_BASE_URL = "https://api.anthropic.com/v1";
-const DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
-const DEFAULT_GOOGLE_BASE_URL = "https://generativelanguage.googleapis.com/v1beta";
-export const TOOL_INPUT_PENDING_THRESHOLD_MS = 5_000;
-type ToolInputActivityStatus = "pending_input" | "streaming_input";
-
-type ToolInputStatusState = {
-  dueAt: number | null;
-  lastStatus: ToolInputActivityStatus | null;
-};
-
-function getToolCallIdFromStreamPart(part: unknown): string | null {
-  if (!part || typeof part !== "object") {
-    return null;
-  }
-
-  const record = part as Record<string, unknown>;
-  if (typeof record.toolCallId === "string" && record.toolCallId.length > 0) {
-    return record.toolCallId;
-  }
-
-  if (typeof record.id === "string" && record.id.length > 0) {
-    return record.id;
-  }
-
-  return null;
-}
-
-function collectDueToolStatuses(
-  toolStates: Map<string, ToolInputStatusState>,
-  now: number,
-  thresholdMs: number,
-): Array<{ type: "data-tool-call-status"; data: { toolCallId: string; status: "pending_input" } }> {
-  const events: Array<
-    { type: "data-tool-call-status"; data: { toolCallId: string; status: "pending_input" } }
-  > = [];
-
-  for (const [toolCallId, state] of toolStates.entries()) {
-    if (state.dueAt === null || state.dueAt > now) {
-      continue;
-    }
-
-    state.dueAt = now + thresholdMs;
-    state.lastStatus = "pending_input";
-    events.push({
-      type: "data-tool-call-status",
-      data: {
-        toolCallId,
-        status: "pending_input",
-      },
-    });
-  }
-
-  return events;
-}
-
-export async function* withToolInputStatusTransitions(
-  stream: AsyncIterable<unknown>,
-  thresholdMs = TOOL_INPUT_PENDING_THRESHOLD_MS,
-): AsyncIterable<unknown> {
-  const iterator = stream[Symbol.asyncIterator]();
-  const toolStates = new Map<string, ToolInputStatusState>();
-  const buffered: unknown[] = [];
-  let nextPartPromise: Promise<IteratorResult<unknown>> | null = null;
-
-  const closeTool = (toolCallId: string | null) => {
-    if (!toolCallId) {
-      return;
-    }
-
-    toolStates.delete(toolCallId);
-  };
-
-  const schedulePending = (toolCallId: string | null) => {
-    if (!toolCallId) {
-      return;
-    }
-
-    const state = toolStates.get(toolCallId) ?? {
-      dueAt: null,
-      lastStatus: null,
-    };
-    state.dueAt = Date.now() + thresholdMs;
-    toolStates.set(toolCallId, state);
-  };
-
-  const markStreaming = (toolCallId: string | null) => {
-    if (!toolCallId) {
-      return;
-    }
-
-    const state = toolStates.get(toolCallId) ?? {
-      dueAt: null,
-      lastStatus: null,
-    };
-
-    if (state.lastStatus !== "streaming_input") {
-      buffered.push({
-        type: "data-tool-call-status",
-        data: {
-          toolCallId,
-          status: "streaming_input",
-        },
-      });
-    }
-
-    state.lastStatus = "streaming_input";
-    state.dueAt = Date.now() + thresholdMs;
-    toolStates.set(toolCallId, state);
-  };
-
-  const processPart = (part: unknown) => {
-    if (!part || typeof part !== "object") {
-      buffered.push(part);
-      return;
-    }
-
-    const record = part as Record<string, unknown>;
-    const partType = typeof record.type === "string" ? record.type : null;
-    const toolCallId = getToolCallIdFromStreamPart(part);
-
-    switch (partType) {
-      case "tool-input-start":
-        schedulePending(toolCallId);
-        buffered.push(part);
-        return;
-      case "tool-input-delta":
-        markStreaming(toolCallId);
-        buffered.push(part);
-        return;
-      case "tool-call":
-      case "tool-result":
-      case "tool-error":
-        closeTool(toolCallId);
-        buffered.push(part);
-        return;
-      case "finish":
-      case "error":
-        toolStates.clear();
-        buffered.push(part);
-        return;
-      default:
-        buffered.push(part);
-        return;
-    }
-  };
-
-  while (true) {
-    if (buffered.length > 0) {
-      yield buffered.shift();
-      continue;
-    }
-
-    if (!nextPartPromise) {
-      nextPartPromise = iterator.next();
-    }
-
-    const nextDueAt = [...toolStates.values()]
-      .map((state) => state.dueAt)
-      .filter((value): value is number => value !== null)
-      .sort((left, right) => left - right)[0] ?? null;
-
-    if (nextDueAt !== null) {
-      let timeoutId: ReturnType<typeof dntShim.setTimeout> | null = null;
-      const timeoutResult = await Promise.race([
-        nextPartPromise.then((result) => ({ kind: "part" as const, result })),
-        new Promise<{ kind: "timeout" }>((resolve) => {
-          timeoutId = dntShim.setTimeout(
-            () => resolve({ kind: "timeout" }),
-            Math.max(0, nextDueAt - Date.now()),
-          );
-        }),
-      ]);
-      if (timeoutId !== null) {
-        clearTimeout(timeoutId);
-      }
-
-      if (timeoutResult.kind === "timeout") {
-        buffered.push(...collectDueToolStatuses(toolStates, Date.now(), thresholdMs));
-        continue;
-      }
-
-      nextPartPromise = null;
-      if (timeoutResult.result.done) {
-        buffered.push(...collectDueToolStatuses(toolStates, Date.now(), thresholdMs));
-        while (buffered.length > 0) {
-          yield buffered.shift();
-        }
-        return;
-      }
-
-      processPart(timeoutResult.result.value);
-      continue;
-    }
-
-    const result = await nextPartPromise;
-    nextPartPromise = null;
-    if (result.done) {
-      return;
-    }
-
-    processPart(result.value);
-  }
-}
-
-function joinUrl(base: string, path: string): string {
-  return `${base.replace(/\/+$/, "")}/${path.replace(/^\/+/, "")}`;
-}
-
-function getOpenAIEmbeddingUrl(baseURL?: string): string {
-  return joinUrl(baseURL ?? DEFAULT_OPENAI_BASE_URL, "embeddings");
-}
-
-function getAnthropicMessagesUrl(baseURL?: string): string {
-  return joinUrl(baseURL ?? DEFAULT_ANTHROPIC_BASE_URL, "messages");
-}
-
-function getOpenAIChatCompletionsUrl(baseURL?: string): string {
-  return joinUrl(baseURL ?? DEFAULT_OPENAI_BASE_URL, "chat/completions");
-}
-
-function getOpenAIResponsesUrl(baseURL?: string): string {
-  return joinUrl(baseURL ?? DEFAULT_OPENAI_BASE_URL, "responses");
-}
-
-function getGoogleGenerateContentUrl(baseURL: string | undefined, modelId: string): string {
-  return joinUrl(
-    baseURL ?? DEFAULT_GOOGLE_BASE_URL,
-    `models/${encodeURIComponent(modelId)}:generateContent`,
-  );
-}
-
-function getGoogleStreamGenerateContentUrl(baseURL: string | undefined, modelId: string): string {
-  return joinUrl(
-    baseURL ?? DEFAULT_GOOGLE_BASE_URL,
-    `models/${encodeURIComponent(modelId)}:streamGenerateContent?alt=sse`,
-  );
-}
-
-function getGoogleEmbeddingUrl(baseURL: string | undefined, modelId: string): string {
-  return joinUrl(
-    baseURL ?? DEFAULT_GOOGLE_BASE_URL,
-    `models/${encodeURIComponent(modelId)}:embedContent`,
-  );
-}
-
 function isNumberArray(value: unknown): value is number[] {
   return Array.isArray(value) && value.every((entry) => typeof entry === "number");
 }
@@ -1054,17 +828,6 @@ function readProviderOptions(
   return merged;
 }
 
-function createRequestHeaders(options: {
-  apiKeyHeaderName: string;
-  apiKey: string;
-  extraHeaders?: HeadersInit;
-}): Headers {
-  const headers = new Headers(options.extraHeaders);
-  headers.set("content-type", "application/json");
-  headers.set(options.apiKeyHeaderName, options.apiKey);
-  return headers;
-}
-
 function normalizeAnthropicFinishReason(
   raw: unknown,
 ): string | { unified: string; raw: string } | null {
@@ -1397,24 +1160,6 @@ function toAnthropicTools(
   return normalized;
 }
 
-function createAnthropicRequestHeaders(options: {
-  apiKey?: string;
-  authToken?: string;
-  extraHeaders?: HeadersInit;
-}): Headers {
-  const headers = new Headers(options.extraHeaders);
-  headers.set("content-type", "application/json");
-  headers.set("anthropic-version", headers.get("anthropic-version") ?? "2023-06-01");
-
-  if (options.authToken) {
-    headers.set("authorization", `Bearer ${options.authToken}`);
-  } else if (options.apiKey) {
-    headers.set("x-api-key", options.apiKey);
-  }
-
-  return headers;
-}
-
 /**
  * Anthropic's Messages API requires `max_tokens` on every call, so the
  * outbound request builder must always supply a number. Picking the right
@@ -2172,6 +1917,25 @@ function isOpenAIReasoningModel(modelId: string): boolean {
   return /^o[134](-|$)/.test(modelId);
 }
 
+/**
+ * Detect native OpenAI models (gpt-*, o-series, chatgpt-*) vs third-party
+ * OpenAI-compatible providers (Kimi, etc.). Native OpenAI models require
+ * `max_completion_tokens` (the old `max_tokens` is rejected by newer models
+ * like gpt-5.2), while third-party providers still expect `max_tokens`.
+ */
+function isNativeOpenAIModel(modelId: string): boolean {
+  return /^(gpt-|o[134](-|$)|chatgpt-)/.test(modelId);
+}
+
+/**
+ * Kimi K2.5 fixes sampling parameters (temperature, top_p, presence_penalty,
+ * frequency_penalty) to predetermined values and rejects any other values.
+ * See https://platform.moonshot.cn/docs/guide/kimi-k2-5-quickstart
+ */
+function isFixedSamplingModel(modelId: string): boolean {
+  return /^kimi-k2\.5/.test(modelId);
+}
+
 /**
  * Map the unified reasoning effort to OpenAI's `reasoning_effort` enum.
  * OpenAI doesn't accept "max" — we collapse it to "high".
@@ -2204,6 +1968,8 @@ function buildOpenAIChatRequest(
   const isReasoningModel = isOpenAIReasoningModel(modelId);
   const reasoningEffort = resolveOpenAIReasoningEffort(options.reasoning);
   const reasoningEnabled = isReasoningModel || reasoningEffort !== undefined;
+  const fixedSampling = isFixedSamplingModel(modelId);
+  const dropSamplingParams = reasoningEnabled || fixedSampling;
 
   // OpenAI Chat Completions has no top_k surface (it's exposed only on the
   // Responses API for some reasoning models). Quietly accepting it would
@@ -2217,10 +1983,10 @@ function buildOpenAIChatRequest(
     });
   }
 
-  // Reasoning models (o1 / o3 / o4) reject sampling params outright. Emit
-  // warnings at build time so callers see *why* the value didn't apply
-  // rather than a 400 from the API.
-  if (reasoningEnabled) {
+  // Reasoning models (o1 / o3 / o4) and models with fixed sampling params
+  // (Kimi K2.5) reject sampling params outright. Emit warnings at build time
+  // so callers see *why* the value didn't apply rather than a 400 from the API.
+  if (dropSamplingParams) {
     const dropped: Array<[keyof typeof options, string]> = [
       ["temperature", "temperature"],
       ["topP", "top_p"],
@@ -2233,8 +1999,9 @@ function buildOpenAIChatRequest(
           type: "unsupported-setting",
           provider: "openai",
           setting: key,
-          details:
-            `Dropped because OpenAI reasoning models reject ${openaiName}. Reasoning was active for this request.`,
+          details: fixedSampling
+            ? `Dropped because this model uses fixed sampling parameters.`
+            : `Dropped because OpenAI reasoning models reject ${openaiName}. Reasoning was active for this request.`,
         });
       }
     }
@@ -2244,13 +2011,17 @@ function buildOpenAIChatRequest(
     model: modelId,
     messages: toOpenAICompatibleMessages(options.prompt),
     ...(stream ? { stream: true, stream_options: { include_usage: true } } : {}),
-    ...(options.maxOutputTokens !== undefined ? { max_tokens: options.maxOutputTokens } : {}),
-    // OpenAI reasoning models reject temperature / top_p / frequency / presence.
-    // Drop them silently rather than letting the API bounce the request.
-    ...(!reasoningEnabled && options.temperature !== undefined
+    ...(options.maxOutputTokens !== undefined
+      ? isNativeOpenAIModel(modelId)
+        ? { max_completion_tokens: options.maxOutputTokens }
+        : { max_tokens: options.maxOutputTokens }
+      : {}),
+    // Reasoning models and fixed-sampling models reject temperature / top_p /
+    // frequency / presence. Drop them rather than letting the API bounce.
+    ...(!dropSamplingParams && options.temperature !== undefined
       ? { temperature: options.temperature }
       : {}),
-    ...(!reasoningEnabled && options.topP !== undefined ? { top_p: options.topP } : {}),
+    ...(!dropSamplingParams && options.topP !== undefined ? { top_p: options.topP } : {}),
     ...(options.stopSequences && options.stopSequences.length > 0
       ? { stop: options.stopSequences }
       : {}),
@@ -2259,10 +2030,10 @@ function buildOpenAIChatRequest(
       : {}),
     ...(options.toolChoice !== undefined ? { tool_choice: options.toolChoice } : {}),
     ...(options.seed !== undefined ? { seed: options.seed } : {}),
-    ...(!reasoningEnabled && options.presencePenalty !== undefined
+    ...(!dropSamplingParams && options.presencePenalty !== undefined
       ? { presence_penalty: options.presencePenalty }
       : {}),
-    ...(!reasoningEnabled && options.frequencyPenalty !== undefined
+    ...(!dropSamplingParams && options.frequencyPenalty !== undefined
       ? { frequency_penalty: options.frequencyPenalty }
       : {}),
     ...(reasoningEffort !== undefined ? { reasoning_effort: reasoningEffort } : {}),
@@ -2292,7 +2063,18 @@ function buildOpenAIChatRequest(
       : {}),
   };
 
-  Object.assign(body, readProviderOptions(options.providerOptions, "openai", providerName));
+  const providerOpts = readProviderOptions(options.providerOptions, "openai", providerName);
+
+  // Normalize max_tokens → max_completion_tokens for native OpenAI models.
+  // Provider options can re-introduce max_tokens which newer models reject.
+  if (isNativeOpenAIModel(modelId) && "max_tokens" in providerOpts) {
+    if (!("max_completion_tokens" in providerOpts)) {
+      providerOpts.max_completion_tokens = providerOpts.max_tokens;
+    }
+    delete providerOpts.max_tokens;
+  }
+
+  Object.assign(body, providerOpts);
   return body;
 }
 
@@ -3056,16 +2838,12 @@ export function createOpenAIModelRuntime(
         fetchImpl,
         providerLabel: config.name ?? "openai",
         providerKind: "openai",
-        init: {
-          method: "POST",
-          headers: createRequestHeaders({
-            apiKeyHeaderName: "authorization",
-            apiKey: `Bearer ${config.apiKey}`,
-            extraHeaders: options.headers,
-          }),
+        init: createOpenAIRequestInit({
+          apiKey: config.apiKey,
+          extraHeaders: options.headers,
           body: JSON.stringify(body),
           signal: options.abortSignal,
-        },
+        }),
       }).then((payload) => {
         const drained = warnings.drain();
         return {
@@ -3090,16 +2868,12 @@ export function createOpenAIModelRuntime(
         fetchImpl,
         providerLabel: config.name ?? "openai",
         providerKind: "openai",
-        init: {
-          method: "POST",
-          headers: createRequestHeaders({
-            apiKeyHeaderName: "authorization",
-            apiKey: `Bearer ${config.apiKey}`,
-            extraHeaders: options.headers,
-          }),
+        init: createOpenAIRequestInit({
+          apiKey: config.apiKey,
+          extraHeaders: options.headers,
           body: JSON.stringify(body),
           signal: options.abortSignal,
-        },
+        }),
       }).then((responseStream) => {
         const drained = warnings.drain();
         return {
@@ -3709,16 +3483,12 @@ export function createOpenAIResponsesRuntime(
         fetchImpl,
         providerLabel: config.name ?? "openai",
         providerKind: "openai",
-        init: {
-          method: "POST",
-          headers: createRequestHeaders({
-            apiKeyHeaderName: "authorization",
-            apiKey: `Bearer ${config.apiKey}`,
-            extraHeaders: options.headers,
-          }),
+        init: createOpenAIRequestInit({
+          apiKey: config.apiKey,
+          extraHeaders: options.headers,
           body: JSON.stringify(body),
           signal: options.abortSignal,
-        },
+        }),
       }).then((payload) => {
         const drained = warnings.drain();
         return {
@@ -3743,16 +3513,12 @@ export function createOpenAIResponsesRuntime(
         fetchImpl,
         providerLabel: config.name ?? "openai",
         providerKind: "openai",
-        init: {
-          method: "POST",
-          headers: createRequestHeaders({
-            apiKeyHeaderName: "authorization",
-            apiKey: `Bearer ${config.apiKey}`,
-            extraHeaders: options.headers,
-          }),
+        init: createOpenAIRequestInit({
+          apiKey: config.apiKey,
+          extraHeaders: options.headers,
           body: JSON.stringify(body),
           signal: options.abortSignal,
-        },
+        }),
       }).then((responseStream) => {
         const drained = warnings.drain();
         return {
@@ -3792,16 +3558,13 @@ export function createAnthropicModelRuntime(
         fetchImpl,
         providerLabel: config.name ?? "anthropic",
         providerKind: "anthropic",
-        init: {
-          method: "POST",
-          headers: createAnthropicRequestHeaders({
-            apiKey: config.apiKey,
-            authToken: config.authToken,
-            extraHeaders: options.headers,
-          }),
+        init: createAnthropicRequestInit({
+          apiKey: config.apiKey,
+          authToken: config.authToken,
+          extraHeaders: options.headers,
           body: JSON.stringify(body),
           signal: options.abortSignal,
-        },
+        }),
       }).then((payload) => {
         const drained = warnings.drain();
         return {
@@ -3826,16 +3589,14 @@ export function createAnthropicModelRuntime(
         fetchImpl,
         providerLabel: config.name ?? "anthropic",
         providerKind: "anthropic",
-        init: {
-          method: "POST",
-          headers: createAnthropicRequestHeaders({
-            apiKey: config.apiKey,
-            authToken: config.authToken,
-            extraHeaders: options.headers,
-          }),
+        init: createAnthropicRequestInit({
+          apiKey: config.apiKey,
+          authToken: config.authToken,
+          extraHeaders: options.headers,
+          enableFineGrainedToolStreaming: true,
           body: JSON.stringify(body),
           signal: options.abortSignal,
-        },
+        }),
       }).then((responseStream) => {
         const drained = warnings.drain();
         return {
@@ -3873,16 +3634,12 @@ export function createGoogleModelRuntime(
         fetchImpl,
         providerLabel: config.name ?? "google",
         providerKind: "google",
-        init: {
-          method: "POST",
-          headers: createRequestHeaders({
-            apiKeyHeaderName: "x-goog-api-key",
-            apiKey: config.apiKey,
-            extraHeaders: options.headers,
-          }),
+        init: createGoogleRequestInit({
+          apiKey: config.apiKey,
+          extraHeaders: options.headers,
           body: JSON.stringify(body),
           signal: options.abortSignal,
-        },
+        }),
       }).then((payload) => {
         const drained = warnings.drain();
         return {
@@ -3905,16 +3662,12 @@ export function createGoogleModelRuntime(
         fetchImpl,
         providerLabel: config.name ?? "google",
         providerKind: "google",
-        init: {
-          method: "POST",
-          headers: createRequestHeaders({
-            apiKeyHeaderName: "x-goog-api-key",
-            apiKey: config.apiKey,
-            extraHeaders: options.headers,
-          }),
+        init: createGoogleRequestInit({
+          apiKey: config.apiKey,
+          extraHeaders: options.headers,
           body: JSON.stringify(body),
           signal: options.abortSignal,
-        },
+        }),
       }).then((responseStream) => {
         const drained = warnings.drain();
         return {
@@ -3952,18 +3705,14 @@ export function createOpenAIEmbeddingRuntime(
         fetchImpl,
         providerLabel: config.name ?? "openai",
         providerKind: "openai",
-        init: {
-          method: "POST",
-          headers: {
-            "content-type": "application/json",
-            authorization: `Bearer ${config.apiKey}`,
-          },
+        init: createOpenAIRequestInit({
+          apiKey: config.apiKey,
           body: JSON.stringify({
             model: modelId,
             input: values,
           }),
           signal: abortSignal,
-        },
+        }),
       }).then((payload) => ({
         embeddings: extractOpenAIEmbeddings(payload),
         usage: {
@@ -4001,19 +3750,15 @@ export function createGoogleEmbeddingRuntime(
           fetchImpl,
           providerLabel: config.name ?? "google",
           providerKind: "google",
-          init: {
-            method: "POST",
-            headers: {
-              "content-type": "application/json",
-              "x-goog-api-key": config.apiKey,
-            },
+          init: createGoogleRequestInit({
+            apiKey: config.apiKey,
             body: JSON.stringify({
               content: {
                 parts: [{ text: value }],
               },
             }),
             signal: abortSignal,
-          },
+          }),
         })
       )).then((payloads) => ({
         embeddings: payloads.map(extractGoogleEmbedding),

package/src/src/proxy/handler.ts

@@ -215,6 +215,15 @@ function parseStatusFromError(error: unknown): number | null {
   return match ? Number(match[1]) : null;
 }
 
+// Brittle on purpose: we string-match the API's OAuth error body. Source of truth is
+// veryfront-api/src/api/http/rest/auth/routes.ts — `oauthError(c, 'Project not found
+// for domain', ...)`. If that string is renamed, this regex silently regresses to 502.
+// Durable fix is a typed error code from the token-mint helper; tracked separately.
+function isMissingCustomDomainProjectError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  return /project not found for domain/i.test(message);
+}
+
 async function extractUserIdFromToken(
   token: string,
   apiBaseUrl: string,
@@ -635,6 +644,13 @@ export function createProxyHandler(options: ProxyHandlerOptions) {
 
       if (isCustomDomain && !projectSlug) {
         if (!token) {
+          if (isMissingCustomDomainProjectError(tokenFetchError)) {
+            logger?.info("Custom domain project not found during token fetch", {
+              domain: host,
+            });
+            return makeErrorContext(base, 404, `No project configured for domain: ${host}`);
+          }
+
           logger?.error("Cannot process custom domain without token", undefined, { domain: host });
           return makeErrorContext(base, 502, `Failed to authenticate for domain: ${host}`, token);
         }