plugin-ai-api 1.1.1 → 1.1.2

package/dist/server/utils/responses-stream.js

@@ -0,0 +1,330 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var responses_stream_exports = {};
+__export(responses_stream_exports, {
+  appendResponseStreamChunk: () => appendResponseStreamChunk,
+  createResponseErrorEvent: () => createResponseErrorEvent,
+  createResponseFailedEvent: () => createResponseFailedEvent,
+  createResponseStartEvents: () => createResponseStartEvents,
+  createResponseStreamState: () => createResponseStreamState,
+  finalizeResponseStream: () => finalizeResponseStream,
+  setResponseStreamUsage: () => setResponseStreamUsage
+});
+module.exports = __toCommonJS(responses_stream_exports);
+var import_responses_format = require("./responses-format");
+function event(state, value) {
+  return { ...value, sequence_number: state.sequenceNumber++ };
+}
+function createResponseStreamState(id, model, requestBody) {
+  return {
+    id,
+    model,
+    requestBody,
+    createdAt: Math.floor(Date.now() / 1e3),
+    sequenceNumber: 0,
+    nextOutputIndex: 0,
+    toolCalls: /* @__PURE__ */ new Map()
+  };
+}
+function responseSnapshot(state, status) {
+  var _a, _b;
+  const content = ((_a = state.textItem) == null ? void 0 : _a.text) ?? "";
+  const reasoningText = (_b = state.reasoningItem) == null ? void 0 : _b.text;
+  const toolCalls = [...state.toolCalls.values()].map(({ item }) => ({
+    id: item.call_id,
+    type: "function",
+    function: { name: item.name, arguments: item.arguments }
+  }));
+  const response = (0, import_responses_format.chatResultToResponse)({
+    id: state.id,
+    model: state.model,
+    content,
+    reasoningText,
+    usage: state.usage,
+    toolCalls,
+    finishReason: state.finishReason,
+    serviceTier: state.serviceTier,
+    requestBody: state.requestBody,
+    status
+  });
+  const indexedOutput = [];
+  if (state.reasoningItem) {
+    indexedOutput.push({
+      index: state.reasoningItem.outputIndex,
+      item: {
+        ...state.reasoningItem.item,
+        status: status === "in_progress" ? "in_progress" : status === "failed" ? "incomplete" : "completed"
+      }
+    });
+  }
+  if (state.textItem) {
+    indexedOutput.push({
+      index: state.textItem.outputIndex,
+      item: {
+        ...state.textItem.item,
+        status: status === "in_progress" ? "in_progress" : status === "failed" || (0, import_responses_format.responseIncompleteReason)(state.finishReason) ? "incomplete" : "completed",
+        content: state.textItem.text ? [{ type: "output_text", text: state.textItem.text, annotations: [] }] : []
+      }
+    });
+  }
+  for (const { item, outputIndex } of state.toolCalls.values()) {
+    indexedOutput.push({
+      index: outputIndex,
+      item: {
+        ...item,
+        status: status === "in_progress" ? "in_progress" : status === "failed" ? "incomplete" : "completed"
+      }
+    });
+  }
+  const output = indexedOutput.sort((left, right) => left.index - right.index).map(({ item }) => item);
+  response.created_at = state.createdAt;
+  response.output = output;
+  response.output_text = content;
+  response.usage = (0, import_responses_format.responseUsageFromOpenAIUsage)(state.usage);
+  return response;
+}
+function createResponseStartEvents(state) {
+  return [
+    event(state, { type: "response.created", response: responseSnapshot(state, "in_progress") }),
+    event(state, { type: "response.in_progress", response: responseSnapshot(state, "in_progress") })
+  ];
+}
+function ensureTextItem(state) {
+  if (state.textItem) return [];
+  const outputIndex = state.nextOutputIndex++;
+  const item = (0, import_responses_format.createResponseOutputMessage)("", "in_progress", (0, import_responses_format.generateResponseItemId)("msg"));
+  state.textItem = { outputIndex, item, text: "" };
+  const part = { type: "output_text", text: "", annotations: [] };
+  return [
+    event(state, { type: "response.output_item.added", output_index: outputIndex, item }),
+    event(state, {
+      type: "response.content_part.added",
+      item_id: item.id,
+      output_index: outputIndex,
+      content_index: 0,
+      part
+    })
+  ];
+}
+function ensureReasoningItem(state) {
+  if (state.reasoningItem) return [];
+  const outputIndex = state.nextOutputIndex++;
+  const item = (0, import_responses_format.createResponseReasoningItem)("");
+  item.status = "in_progress";
+  state.reasoningItem = { outputIndex, item, text: "" };
+  return [
+    event(state, { type: "response.output_item.added", output_index: outputIndex, item }),
+    event(state, {
+      type: "response.content_part.added",
+      item_id: item.id,
+      output_index: outputIndex,
+      content_index: 0,
+      part: { type: "reasoning_text", text: "" }
+    })
+  ];
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function appendToolCallChunks(state, value) {
+  if (!Array.isArray(value)) return [];
+  const events = [];
+  for (const [fallbackIndex, raw] of value.entries()) {
+    if (!isRecord(raw)) continue;
+    const index = typeof raw.index === "number" ? raw.index : fallbackIndex;
+    const functionValue = isRecord(raw.function) ? raw.function : void 0;
+    const id = typeof raw.id === "string" ? raw.id : void 0;
+    const name = typeof raw.name === "string" ? raw.name : typeof (functionValue == null ? void 0 : functionValue.name) === "string" ? functionValue.name : void 0;
+    const argumentsDelta = typeof raw.args === "string" ? raw.args : typeof (functionValue == null ? void 0 : functionValue.arguments) === "string" ? functionValue.arguments : raw.args === void 0 ? "" : JSON.stringify(raw.args);
+    let call = state.toolCalls.get(index);
+    if (!call) {
+      const callId = id ?? (0, import_responses_format.generateResponseItemId)("fc");
+      const item = {
+        id: (0, import_responses_format.generateResponseItemId)("fc"),
+        type: "function_call",
+        status: "in_progress",
+        call_id: callId,
+        name: name ?? "",
+        arguments: ""
+      };
+      call = { outputIndex: state.nextOutputIndex++, item };
+      state.toolCalls.set(index, call);
+      events.push(event(state, { type: "response.output_item.added", output_index: call.outputIndex, item }));
+    }
+    if (name) call.item.name = name;
+    if (id) call.item.call_id = id;
+    if (argumentsDelta) {
+      call.item.arguments += argumentsDelta;
+      events.push(
+        event(state, {
+          type: "response.function_call_arguments.delta",
+          item_id: call.item.id,
+          output_index: call.outputIndex,
+          delta: argumentsDelta
+        })
+      );
+    }
+  }
+  return events;
+}
+function appendResponseStreamChunk(state, chunk) {
+  if (!isRecord(chunk)) return [];
+  const events = [];
+  const reasoningDelta = (0, import_responses_format.extractReasoningText)(chunk);
+  if (reasoningDelta) {
+    events.push(...ensureReasoningItem(state));
+    const reasoning = state.reasoningItem;
+    reasoning.text += reasoningDelta;
+    reasoning.item.content = [{ type: "reasoning_text", text: reasoning.text }];
+    events.push(
+      event(state, {
+        type: "response.reasoning_text.delta",
+        item_id: reasoning.item.id,
+        output_index: reasoning.outputIndex,
+        content_index: 0,
+        delta: reasoningDelta
+      })
+    );
+  }
+  const content = (0, import_responses_format.extractResponseOutputText)(chunk);
+  if (content) {
+    events.push(...ensureTextItem(state));
+    const text = state.textItem;
+    text.text += content;
+    text.item.content = [{ type: "output_text", text: text.text, annotations: [] }];
+    events.push(
+      event(state, {
+        type: "response.output_text.delta",
+        item_id: text.item.id,
+        output_index: text.outputIndex,
+        content_index: 0,
+        delta: content,
+        logprobs: []
+      })
+    );
+  }
+  events.push(...appendToolCallChunks(state, chunk.tool_call_chunks));
+  const finishReason = [chunk.response_metadata, chunk.additional_kwargs].filter(isRecord).map((metadata) => metadata.finish_reason).find((candidate) => typeof candidate === "string" && candidate.length > 0);
+  const incompleteReason = (0, import_responses_format.extractResponseIncompleteReason)(chunk);
+  if (finishReason || incompleteReason) state.finishReason = finishReason ?? incompleteReason;
+  state.serviceTier = state.serviceTier ?? (0, import_responses_format.extractResponseServiceTier)(chunk);
+  return events;
+}
+function setResponseStreamUsage(state, usage) {
+  if (usage) state.usage = usage;
+}
+function finalizeResponseStream(state) {
+  const events = [];
+  const incompleteReason = (0, import_responses_format.responseIncompleteReason)(state.finishReason);
+  if (state.reasoningItem) {
+    const { item, outputIndex, text } = state.reasoningItem;
+    item.status = "completed";
+    events.push(
+      event(state, {
+        type: "response.reasoning_text.done",
+        item_id: item.id,
+        output_index: outputIndex,
+        content_index: 0,
+        text
+      }),
+      event(state, {
+        type: "response.content_part.done",
+        item_id: item.id,
+        output_index: outputIndex,
+        content_index: 0,
+        part: { type: "reasoning_text", text }
+      }),
+      event(state, { type: "response.output_item.done", output_index: outputIndex, item })
+    );
+  }
+  if (state.textItem) {
+    const { item, outputIndex, text } = state.textItem;
+    item.status = incompleteReason ? "incomplete" : "completed";
+    const part = { type: "output_text", text, annotations: [] };
+    item.content = [part];
+    events.push(
+      event(state, {
+        type: "response.output_text.done",
+        item_id: item.id,
+        output_index: outputIndex,
+        content_index: 0,
+        text,
+        logprobs: []
+      }),
+      event(state, {
+        type: "response.content_part.done",
+        item_id: item.id,
+        output_index: outputIndex,
+        content_index: 0,
+        part
+      }),
+      event(state, { type: "response.output_item.done", output_index: outputIndex, item })
+    );
+  }
+  for (const { item, outputIndex } of state.toolCalls.values()) {
+    item.status = "completed";
+    events.push(
+      event(state, {
+        type: "response.function_call_arguments.done",
+        item_id: item.id,
+        output_index: outputIndex,
+        name: item.name,
+        arguments: item.arguments
+      }),
+      event(state, { type: "response.output_item.done", output_index: outputIndex, item })
+    );
+  }
+  const response = responseSnapshot(state, incompleteReason ? "incomplete" : "completed");
+  events.push(
+    event(state, { type: response.status === "incomplete" ? "response.incomplete" : "response.completed", response })
+  );
+  return events;
+}
+function createResponseErrorEvent(state, error) {
+  return event(state, {
+    type: "error",
+    code: error.code ?? "server_error",
+    message: error.message,
+    param: null
+  });
+}
+function createResponseFailedEvent(state, error) {
+  const response = responseSnapshot(state, "failed");
+  response.error = { code: error.code ?? "server_error", message: error.message };
+  response.completed_at = null;
+  return event(state, { type: "response.failed", response });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  appendResponseStreamChunk,
+  createResponseErrorEvent,
+  createResponseFailedEvent,
+  createResponseStartEvents,
+  createResponseStreamState,
+  finalizeResponseStream,
+  setResponseStreamUsage
+});

package/dist/server/utils/virtual-models.js

@@ -0,0 +1,238 @@
+/**
+ * This file is part of the NocoBase (R) project.
+ * Copyright (c) 2020-2024 NocoBase Co., Ltd.
+ * Authors: NocoBase Team.
+ *
+ * This project is dual-licensed under AGPL-3.0 and NocoBase Commercial License.
+ * For more information, please refer to: https://www.nocobase.com/agreement.
+ */
+
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var virtual_models_exports = {};
+__export(virtual_models_exports, {
+  detectRequestSignals: () => detectRequestSignals,
+  listAccessibleVirtualModels: () => listAccessibleVirtualModels,
+  resolveVirtualModel: () => resolveVirtualModel,
+  respondVirtualModelUnavailable: () => respondVirtualModelUnavailable
+});
+module.exports = __toCommonJS(virtual_models_exports);
+var import_openai_format = require("./openai-format");
+var import_resolve_service = require("./resolve-service");
+var import_user_permissions = require("./user-permissions");
+var import_request_cache = require("./request-cache");
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function contentHasImage(content) {
+  if (!Array.isArray(content)) return false;
+  return content.some((block) => {
+    if (!isRecord(block)) return false;
+    if (block.type === "image_url") return true;
+    if (block.type === "file") return true;
+    if (block.type === "file_url") return true;
+    return false;
+  });
+}
+function detectRequestSignals(body) {
+  const messages = Array.isArray(body.messages) ? body.messages : [];
+  const hasImage = messages.some((msg) => isRecord(msg) && contentHasImage(msg.content));
+  const hasTools = Array.isArray(body.tools) && body.tools.length > 0;
+  const rf = body.response_format;
+  const wantsStructuredOutput = isRecord(rf) && (rf.type === "json_object" || rf.type === "json_schema");
+  const wantsReasoning = Object.hasOwn(body, "reasoning") && body.reasoning !== void 0 && body.reasoning !== null || Object.hasOwn(body, "reasoning_effort") && body.reasoning_effort !== void 0 && body.reasoning_effort !== null;
+  return { hasImage, hasTools, wantsStructuredOutput, wantsReasoning };
+}
+function valueOf(model, key) {
+  if (!model) return void 0;
+  if (typeof model.get === "function") {
+    return model.get(key);
+  }
+  return model[key];
+}
+function stringList(value) {
+  return Array.isArray(value) ? value.filter((v) => typeof v === "string" && v.length > 0) : [];
+}
+function toVirtualModel(row, fallbackName = "") {
+  return {
+    name: String(valueOf(row, "name") ?? fallbackName),
+    mode: valueOf(row, "mode") === "embedding" ? "embedding" : "chat",
+    fallbackModel: String(valueOf(row, "fallbackModel") ?? ""),
+    visionModels: stringList(valueOf(row, "visionModels")),
+    toolModels: stringList(valueOf(row, "toolModels")),
+    reasoningModels: stringList(valueOf(row, "reasoningModels")),
+    cheapModels: stringList(valueOf(row, "cheapModels")),
+    generalModels: stringList(valueOf(row, "generalModels")),
+    enabled: valueOf(row, "enabled")
+  };
+}
+async function loadVirtualModel(ctx, name) {
+  const row = await ctx.db.getRepository("aiApiVirtualModels").findOne({ filter: { name, enabled: true } });
+  return row ? toVirtualModel(row, name) : null;
+}
+async function deriveBucket(ctx, capability) {
+  const repo = ctx.db.getRepository("aiApiModelMetadata");
+  const filter = { enabled: true };
+  if (capability === "vision") filter.supportsVision = true;
+  else if (capability === "tool") filter.supportsToolCalling = true;
+  else if (capability === "reasoning") filter.reasoningTier = "reasoning";
+  else filter.reasoningTier = { $in: ["general", "cheap", "reasoning"] };
+  const rows = await repo.find({ filter, sort: "sortOrder", pageSize: 200 });
+  const list = rows.map((row) => {
+    const service = valueOf(row, "llmService");
+    const model = valueOf(row, "model");
+    return service && model ? `${service}/${model}` : "";
+  });
+  return list.filter(Boolean);
+}
+async function bucketFor(ctx, vm, signals) {
+  const explicit = (list) => list && list.length ? list : null;
+  if (signals.hasImage) {
+    return { reason: "vision", candidates: explicit(vm.visionModels) ?? await deriveBucket(ctx, "vision") };
+  }
+  if (signals.hasTools) {
+    return { reason: "tools", candidates: explicit(vm.toolModels) ?? await deriveBucket(ctx, "tool") };
+  }
+  if (signals.wantsReasoning) {
+    return { reason: "reasoning", candidates: explicit(vm.reasoningModels) ?? await deriveBucket(ctx, "reasoning") };
+  }
+  if (signals.wantsStructuredOutput) {
+    return {
+      reason: "structured_output",
+      candidates: explicit(vm.generalModels) ?? await deriveBucket(ctx, "general")
+    };
+  }
+  const cheap = explicit(vm.cheapModels);
+  if (cheap) return { reason: "cheap", candidates: cheap };
+  return { reason: "general", candidates: explicit(vm.generalModels) ?? await deriveBucket(ctx, "general") };
+}
+async function resolveVirtualModel(ctx, alias, body, requestedMode) {
+  const vm = await loadVirtualModel(ctx, alias);
+  if (!vm) return null;
+  if (vm.mode !== requestedMode) {
+    return {
+      status: "unavailable",
+      virtualModel: alias,
+      reason: "mode_mismatch",
+      configuredMode: vm.mode,
+      requestedMode
+    };
+  }
+  const config = await (0, import_request_cache.getAiApiConfig)(ctx);
+  const globalServices = valueOf(config, "enabledLlmServices") ?? [];
+  const scope = await (0, import_user_permissions.resolveUserAccessScope)(ctx);
+  if (scope.lookupFailed) {
+    return {
+      status: "unavailable",
+      virtualModel: alias,
+      reason: "permission_check_failed",
+      configuredMode: vm.mode,
+      requestedMode
+    };
+  }
+  const usable = (service, modelId) => valueOf(service, "enabled") !== false && (0, import_user_permissions.isServiceAllowed)(scope, globalServices, {
+    name: valueOf(service, "name"),
+    title: valueOf(service, "title")
+  }) && (0, import_user_permissions.isModelAllowed)(scope, `${valueOf(service, "name")}/${modelId}`);
+  if (requestedMode === "embedding") {
+    const fallback2 = await (0, import_resolve_service.resolveModelReference)(ctx, vm.fallbackModel);
+    if (fallback2 && usable(fallback2.service, fallback2.modelId)) {
+      return { status: "resolved", virtualModel: alias, reason: "fallback", resolved: fallback2 };
+    }
+    return {
+      status: "unavailable",
+      virtualModel: alias,
+      reason: "no_permitted_model",
+      configuredMode: vm.mode,
+      requestedMode
+    };
+  }
+  const signals = detectRequestSignals(body);
+  const { reason, candidates } = await bucketFor(ctx, vm, signals);
+  for (const candidate of candidates) {
+    const resolved = await (0, import_resolve_service.resolveModelReference)(ctx, candidate);
+    if (resolved && usable(resolved.service, resolved.modelId)) {
+      return { status: "resolved", virtualModel: alias, reason, resolved };
+    }
+  }
+  const fallback = await (0, import_resolve_service.resolveModelReference)(ctx, vm.fallbackModel);
+  if (fallback && usable(fallback.service, fallback.modelId)) {
+    return { status: "resolved", virtualModel: alias, reason: "fallback", resolved: fallback };
+  }
+  return {
+    status: "unavailable",
+    virtualModel: alias,
+    reason: "no_permitted_model",
+    configuredMode: vm.mode,
+    requestedMode
+  };
+}
+async function listAccessibleVirtualModels(ctx, scope, globalServices) {
+  const rows = await ctx.db.getRepository("aiApiVirtualModels").find({ filter: { enabled: true } });
+  const accessible = [];
+  for (const row of rows) {
+    const vm = toVirtualModel(row);
+    if (!vm.fallbackModel) continue;
+    const resolved = await (0, import_resolve_service.resolveModelReference)(ctx, vm.fallbackModel);
+    if (!resolved || valueOf(resolved.service, "enabled") === false) continue;
+    const service = {
+      name: valueOf(resolved.service, "name"),
+      title: valueOf(resolved.service, "title")
+    };
+    if ((0, import_user_permissions.isServiceAllowed)(scope, globalServices, service) && (0, import_user_permissions.isModelAllowed)(scope, `${service.name}/${resolved.modelId}`)) {
+      accessible.push(vm);
+    }
+  }
+  return accessible;
+}
+function respondVirtualModelUnavailable(ctx, result) {
+  if (result.reason === "permission_check_failed") {
+    ctx.status = 503;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      503,
+      "Unable to verify LLM permissions for this user. Please retry shortly.",
+      "service_unavailable",
+      "permission_check_failed"
+    );
+    return;
+  }
+  if (result.reason === "mode_mismatch") {
+    ctx.status = 404;
+    ctx.body = (0, import_openai_format.toOpenAIError)(
+      404,
+      `Virtual model '${result.virtualModel}' serves ${result.configuredMode} requests and cannot be used for ${result.requestedMode} requests.`,
+      "invalid_request_error",
+      "model_not_found"
+    );
+    return;
+  }
+  ctx.status = 403;
+  ctx.body = (0, import_openai_format.toOpenAIError)(
+    403,
+    `No model behind virtual alias '${result.virtualModel}' is available to this user. Use GET /v1/models to see available models.`,
+    "permission_denied",
+    "model_not_available"
+  );
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  detectRequestSignals,
+  listAccessibleVirtualModels,
+  resolveVirtualModel,
+  respondVirtualModelUnavailable
+});

package/dist/server/validation.js

@@ -38,7 +38,8 @@ var validation_exports = {};
 __export(validation_exports, {
   validateModelMetadata: () => validateModelMetadata,
   validateModelPrice: () => validateModelPrice,
-  validateQuotaPolicy: () => validateQuotaPolicy
+  validateQuotaPolicy: () => validateQuotaPolicy,
+  validateVirtualModel: () => validateVirtualModel
 });
 module.exports = __toCommonJS(validation_exports);
 var import_dayjs = __toESM(require("dayjs"));
@@ -84,6 +85,14 @@ function requirePositiveIntegerOrNull(value, field) {
   const parsed = Number(value);
   if (!Number.isSafeInteger(parsed) || parsed <= 0) throw new Error(`${field} must be a positive integer.`);
 }
+function requireBooleanOrNull(value, field) {
+  if (value === null || value === void 0) return;
+  if (typeof value !== "boolean") throw new Error(`${field} must be a boolean.`);
+}
+function requireInteger(value, field) {
+  if (value === null || value === void 0 || value === "") return;
+  if (!Number.isSafeInteger(Number(value))) throw new Error(`${field} must be an integer.`);
+}
 function validateModelMetadata(model) {
   if (!String(model.get("llmService") ?? "").trim()) throw new Error("llmService is required.");
   if (!String(model.get("model") ?? "").trim()) throw new Error("model is required.");
@@ -93,12 +102,44 @@ function validateModelMetadata(model) {
   if (systemPrompt !== null && systemPrompt !== void 0 && typeof systemPrompt !== "string") {
     throw new Error("systemPrompt must be a string.");
   }
+  requireBooleanOrNull(model.get("supportsVision"), "supportsVision");
+  requireBooleanOrNull(model.get("supportsToolCalling"), "supportsToolCalling");
+  requireBooleanOrNull(model.get("enabled"), "enabled");
+  const reasoningTier = model.get("reasoningTier");
+  if (reasoningTier !== null && reasoningTier !== void 0 && !["cheap", "general", "reasoning"].includes(String(reasoningTier))) {
+    throw new Error("reasoningTier must be cheap, general, or reasoning.");
+  }
+  requireInteger(model.get("sortOrder"), "sortOrder");
   const contextWindow = model.get("contextWindow");
   const maxCompletionTokens = model.get("maxCompletionTokens");
   if (contextWindow !== null && contextWindow !== void 0 && contextWindow !== "" && maxCompletionTokens !== null && maxCompletionTokens !== void 0 && maxCompletionTokens !== "" && Number(maxCompletionTokens) > Number(contextWindow)) {
     throw new Error("maxCompletionTokens cannot exceed contextWindow.");
   }
 }
+function requireModelReference(value, field) {
+  const normalized = typeof value === "string" ? value.trim() : "";
+  const slash = normalized.indexOf("/");
+  if (slash <= 0 || slash === normalized.length - 1) {
+    throw new Error(`${field} must use the service/modelId format.`);
+  }
+}
+function requireModelReferenceList(value, field) {
+  if (value === null || value === void 0) return;
+  if (!Array.isArray(value)) throw new Error(`${field} must be an array.`);
+  value.forEach((item, index) => requireModelReference(item, `${field}[${index}]`));
+}
+function validateVirtualModel(model) {
+  if (!String(model.get("name") ?? "").trim()) throw new Error("name is required.");
+  const mode = model.get("mode");
+  if (mode !== null && mode !== void 0 && !["chat", "embedding"].includes(String(mode))) {
+    throw new Error("mode must be chat or embedding.");
+  }
+  requireModelReference(model.get("fallbackModel"), "fallbackModel");
+  for (const field of ["visionModels", "toolModels", "reasoningModels", "cheapModels", "generalModels"]) {
+    requireModelReferenceList(model.get(field), field);
+  }
+  requireBooleanOrNull(model.get("enabled"), "enabled");
+}
 function validateQuotaPolicy(model) {
   if (!["daily", "monthly"].includes(String(model.get("periodType")))) {
     throw new Error("periodType must be daily or monthly.");
@@ -127,5 +168,6 @@ function validateQuotaPolicy(model) {
 0 && (module.exports = {
   validateModelMetadata,
   validateModelPrice,
-  validateQuotaPolicy
+  validateQuotaPolicy,
+  validateVirtualModel
 });