@mupt-ai/dari-router 0.1.0 → 0.2.0

package/src/framework_types.ts

@@ -1,372 +0,0 @@
-import type { ReasoningEffort, RoutingDecision } from "./types.js";
-import type {
-  RouterContinuationState,
-  RouterProviderIdentity,
-} from "./continuation_state.js";
-import type { RouterFrameworkError } from "./framework_error.js";
-
-export type { RouterContinuationState, RouterProviderIdentity } from "./continuation_state.js";
-
-export type RouterProtocol = "openai_chat_completions" | "anthropic_messages";
-
-export type RouterTextContent = {
-  type: "text";
-  text: string;
-};
-
-export type RouterImageContent = {
-  type: "image";
-  url: string;
-  detail?: "auto" | "low" | "high";
-};
-
-export type RouterContent = RouterTextContent | RouterImageContent;
-
-export type RouterMessageItem = {
-  type: "message";
-  role: "system" | "developer" | "user" | "assistant";
-  content: RouterContent[];
-};
-
-export type RouterToolCallItem = {
-  type: "tool_call";
-  id: string;
-  name: string;
-  arguments: string | Record<string, unknown>;
-};
-
-export type RouterToolResultItem = {
-  type: "tool_result";
-  toolCallId: string;
-  content: RouterContent[];
-  isError?: boolean;
-};
-
-// Provider-hosted tools (for example OpenAI/Anthropic web search). These are
-// replayable provider-native calls, not user-defined function tools.
-export type RouterHostedToolCallStatus =
-  | "in_progress"
-  | "searching"
-  | "completed"
-  | "incomplete"
-  | "failed";
-
-export function isRouterHostedToolCallStatus(
-  value: unknown,
-): value is RouterHostedToolCallStatus {
-  return value === "in_progress" || value === "searching" || value === "completed" ||
-    value === "incomplete" || value === "failed";
-}
-
-export type RouterHostedToolCallItem = {
-  type: "hosted_tool_call";
-  id: string;
-  tool: "web_search";
-  providerType: "web_search_call";
-  status?: RouterHostedToolCallStatus;
-  payload: Record<string, unknown>;
-  source?: RouterProviderIdentity;
-};
-
-// Prior-turn reasoning/thinking carried across turns. The framework does not
-// translate encrypted blobs between providers; it carries them tagged with
-// their source provider identity and executors drop/refuse cross-provider
-// continuations (see compatibleContinuation).
-export type RouterReasoningItem = {
-  type: "reasoning";
-  id?: string;
-  summary?: string[];
-  content: string[];
-  source?: RouterProviderIdentity;
-  continuation?: RouterContinuationState;
-};
-
-export type RouterInputItem =
-  | RouterMessageItem
-  | RouterToolCallItem
-  | RouterToolResultItem
-  | RouterReasoningItem
-  | RouterHostedToolCallItem;
-
-export type RouterTool = {
-  name: string;
-  description?: string;
-  inputSchema: Record<string, unknown>;
-  strict?: boolean;
-};
-
-export type RouterToolChoice =
-  | "none"
-  | "auto"
-  | "required"
-  | { type: "tool"; name: string };
-
-export type RouterResponseFormat =
-  | { type: "text" }
-  | { type: "json_object" }
-  | {
-      type: "json_schema";
-      name: string;
-      schema: Record<string, unknown>;
-      description?: string;
-      strict?: boolean;
-    };
-
-export type RouterRequest = {
-  protocol: RouterProtocol;
-  requestedModel: string;
-  items: RouterInputItem[];
-  tools: RouterTool[];
-  toolChoice?: RouterToolChoice;
-  parallelToolCalls?: boolean;
-  generation: {
-    temperature?: number;
-    topP?: number;
-    maxOutputTokens?: number;
-    stop?: string | string[];
-  };
-  reasoning?: {
-    effort?: ReasoningEffort;
-    enabled?: boolean;
-    budgetTokens?: number;
-  };
-  responseFormat?: RouterResponseFormat;
-  cacheKey?: string;
-  stream: boolean;
-  metadata?: Record<string, unknown>;
-  user?: string;
-};
-
-export type RouterModelCapabilities = {
-  imageInput?: boolean;
-  toolUse?: boolean;
-  structuredOutput?: boolean;
-  streaming?: boolean;
-};
-
-export type RouterModel<Metadata = unknown> = {
-  id: string;
-  executor?: string;
-  provider?: string;
-  api?: string;
-  reasoningEfforts?: readonly ReasoningEffort[];
-  defaultReasoningEffort?: ReasoningEffort;
-  capabilities?: RouterModelCapabilities;
-  metadata?: Metadata;
-};
-
-export type RouterCandidate<Metadata = unknown> = {
-  id: string;
-  executor: string;
-  provider: string;
-  api: string;
-  reasoningEfforts: readonly ReasoningEffort[];
-  defaultReasoningEffort: ReasoningEffort;
-  capabilities: Required<RouterModelCapabilities>;
-  metadata?: Metadata;
-};
-
-export type RoutingPolicyInput<Metadata = unknown> = {
-  request: RouterRequest;
-  candidates: readonly RouterCandidate<Metadata>[];
-  signal: AbortSignal;
-};
-
-export type RoutingPolicyDecision = {
-  model: string;
-  reasoningEffort?: ReasoningEffort;
-  reason?: string;
-  // Turns the policy commits to this selection after the current one. When
-  // set, createRouter serves the same model for subsequent requests sharing
-  // the same cacheKey without calling the policy again.
-  leaseTurnsRemaining?: number;
-  details?: unknown;
-};
-
-export type RoutingPolicy<Metadata = unknown> =
-  | ((input: RoutingPolicyInput<Metadata>) => RoutingPolicyDecision | Promise<RoutingPolicyDecision>)
-  | {
-      select(input: RoutingPolicyInput<Metadata>): RoutingPolicyDecision | Promise<RoutingPolicyDecision>;
-    };
-
-export type RouterSelection<Metadata = unknown> = {
-  decision: RoutingDecision;
-  candidates: readonly RouterCandidate<Metadata>[];
-  policyDetails?: unknown;
-};
-
-export type RouterUsage = {
-  // Non-cached input tokens. Cache reads/writes are separate counts, not
-  // subsets of inputTokens; protocol serializers fold them per each wire
-  // format's own semantics.
-  inputTokens: number;
-  outputTokens: number;
-  cacheReadTokens?: number;
-  cacheWriteTokens?: number;
-  totalTokens?: number;
-};
-
-export type RouterFinishReason = "stop" | "length" | "tool_calls";
-
-export type RouterOutputText = {
-  type: "text";
-  text: string;
-};
-
-export type RouterOutputToolCall = {
-  type: "tool_call";
-  id: string;
-  name: string;
-  arguments: string | Record<string, unknown>;
-};
-
-export type RouterOutputReasoning = {
-  type: "reasoning";
-  // Readable thinking text (plaintext summary or content). Empty for purely
-  // redacted thinking, where only the encrypted continuation is available.
-  text: string;
-  redacted?: boolean;
-  source?: RouterProviderIdentity;
-  continuation?: RouterContinuationState;
-};
-
-export type RouterOutputHostedToolCall = {
-  type: "hosted_tool_call";
-  id: string;
-  tool: "web_search";
-  providerType: "web_search_call";
-  status?: RouterHostedToolCallStatus;
-  payload: Record<string, unknown>;
-  source?: RouterProviderIdentity;
-};
-
-export type RouterOutputItem =
-  | RouterOutputText
-  | RouterOutputToolCall
-  | RouterOutputReasoning
-  | RouterOutputHostedToolCall;
-
-export type RouterCompletion = {
-  id?: string;
-  createdAtMs?: number;
-  content: RouterOutputItem[];
-  finishReason: RouterFinishReason;
-  usage?: RouterUsage;
-};
-
-export type RouterStreamEvent =
-  | { type: "text_delta"; index: number; delta: string }
-  | { type: "tool_call_start"; index: number; id: string; name: string }
-  | { type: "tool_call_delta"; index: number; delta: string }
-  | { type: "tool_call_end"; index: number }
-  | { type: "reasoning_delta"; index: number; delta: string }
-  // Hosted tool executions (provider-run web search) arrive complete rather
-  // than incrementally: one event carries the full replayable item.
-  | (RouterOutputHostedToolCall & { index: number })
-  | {
-      type: "reasoning_end";
-      index: number;
-      redacted?: boolean;
-      // Provider identity and stable item id for signing plain (no-
-      // continuation) reasoning with a portable envelope on replayable wire
-      // formats.
-      source?: RouterProviderIdentity;
-      itemId?: string;
-      continuation?: import("./continuation_state.js").ProviderContinuationState;
-    }
-  | { type: "finish"; finishReason: RouterFinishReason; usage?: RouterUsage };
-
-export type RouterExecutorResult =
-  | { type: "complete"; output: RouterCompletion }
-  | { type: "stream"; events: AsyncIterable<RouterStreamEvent> };
-
-export type RouterExecutorInput<Metadata = unknown> = {
-  request: RouterRequest;
-  model: RouterCandidate<Metadata>;
-  decision: RoutingDecision;
-  signal: AbortSignal;
-};
-
-export type RouterExecutor<Metadata = unknown> = {
-  execute(
-    input: RouterExecutorInput<Metadata>,
-  ): RouterExecutorResult | Promise<RouterExecutorResult>;
-};
-
-export type CreateRouterOptions<Metadata = unknown> = {
-  models: readonly RouterModel<Metadata>[];
-  policy: RoutingPolicy<Metadata>;
-  runtime?: RouterExecutor<Metadata>;
-  executors?: Readonly<Record<string, RouterExecutor<Metadata>>>;
-  generateId?: () => string;
-  // Pluggable lease store. When omitted, createRouter uses an in-memory
-  // store with a 30-minute TTL. Inject a persistent store to share leases
-  // across processes (e.g. the managed backend's DB-backed leases).
-  leaseStore?: LeaseStore;
-  // Lifecycle hooks for telemetry, billing, and logging. All hooks are
-  // optional and fire-and-forget: createRouter never awaits them on the
-  // hot path.
-  hooks?: RouterHooks<Metadata>;
-  // Fallback configuration. When the primary executor fails, createRouter
-  // retries on a fallback model if one is available and eligible.
-  fallback?: RouterFallbackConfig;
-};
-
-export type Router<Metadata = unknown> = {
-  readonly models: readonly RouterCandidate<Metadata>[];
-  select(request: RouterRequest, signal?: AbortSignal): Promise<RouterSelection<Metadata>>;
-  fetch(request: Request): Promise<Response>;
-};
-
-// A lease commitment: the router serves the same model for subsequent
-// requests sharing the cacheKey without calling the policy again.
-export type RouterLease = {
-  model: string;
-  reasoningEffort: ReasoningEffort;
-  turnsRemaining: number;
-  expiresAt: number;
-};
-
-// Pluggable lease storage. The default in-memory implementation has a
-// 30-minute TTL; inject a persistent store for cross-process leases. Methods
-// may be synchronous or return promises (DB-backed stores). Read-modify-write
-// atomicity under concurrent requests is the store's responsibility. Every
-// call is advisory: a store that throws or rejects never fails the request.
-export interface LeaseStore {
-  get(cacheKey: string): RouterLease | undefined | Promise<RouterLease | undefined>;
-  set(cacheKey: string, lease: RouterLease): void | Promise<void>;
-  delete(cacheKey: string): void | Promise<void>;
-  // Remove all expired leases. Called on every cacheKey-bearing selection.
-  pruneExpired(nowMs: number): void | Promise<void>;
-}
-
-// onSelection observes the policy's decision before execution. The other
-// hooks receive the selection actually served: after a successful fallback
-// its decision names the fallback model, states the fallback in its reason,
-// and carries no leaseTurnsRemaining (the primary's lease was released).
-export type RouterHooks<Metadata = unknown> = {
-  // Fires after a successful selection (including lease short-circuits).
-  onSelection?(selection: RouterSelection<Metadata>, request: RouterRequest): void;
-  // Fires after a successful completion (non-streaming). For streaming
-  // completions, use onStreamClose which fires when the stream finishes.
-  onCompletion?(completion: RouterCompletion, selection: RouterSelection<Metadata>): void;
-  // Fires when a stream finishes successfully or with an error. The
-  // completion deliberately carries content: [] — the router does not buffer
-  // streamed output; only finishReason and usage are populated.
-  onStreamClose?(
-    completion: RouterCompletion | null,
-    selection: RouterSelection<Metadata>,
-    error: RouterFrameworkError | null,
-  ): void;
-  // Fires when the executor or stream fails.
-  onError?(error: RouterFrameworkError, selection: RouterSelection<Metadata>): void;
-};
-
-// Executor-failure fallback for createRouter. Distinct from the phased API's
-// RouteFallbackConfig, which defaults both flags ON; here everything defaults OFF.
-export type RouterFallbackConfig = {
-  // Whether fallback is enabled (default: false).
-  enabled?: boolean;
-  // Require the fallback model to be from a different provider (default: false).
-  requiresDifferentProvider?: boolean;
-};

package/src/framework_validation.ts

@@ -1,235 +0,0 @@
-import { RouterFrameworkError } from "./framework_error.js";
-import {
-  completionContract,
-  streamContract,
-} from "./framework_lifecycle.js";
-import { isReasoningEffort } from "./types.js";
-import type {
-  RouterCandidate,
-  RouterCompletion,
-  RouterFinishReason,
-  RouterSelection,
-  RouterStreamEvent,
-  RoutingPolicyDecision,
-} from "./framework_types.js";
-
-export function validateStreamSequence(
-  event: Exclude<RouterStreamEvent, { type: "finish" }>,
-  openIndexes: Map<number, "text" | "tool" | "reasoning">,
-): void {
-  const current = openIndexes.get(event.index);
-  if (event.type === "text_delta") {
-    if (current === "tool" || current === "reasoning") throw streamContract(`Stream index ${event.index} is already a ${current} block.`);
-    if (current === undefined) openIndexes.set(event.index, "text");
-    return;
-  }
-  if (event.type === "reasoning_delta") {
-    if (current === "tool" || current === "text") throw streamContract(`Stream index ${event.index} is already a ${current} block.`);
-    if (current === undefined) openIndexes.set(event.index, "reasoning");
-    return;
-  }
-  if (event.type === "reasoning_end") {
-    if (current === "text" || current === "tool") throw streamContract(`Stream index ${event.index} is already a ${current} block.`);
-    if (current === "reasoning") openIndexes.delete(event.index);
-    // If current is undefined, reasoning_end opens and immediately closes a
-    // reasoning block (empty or redacted thinking with no prior delta).
-    return;
-  }
-  if (event.type === "tool_call_start") {
-    if (current !== undefined) throw streamContract(`Stream index ${event.index} is already in use.`);
-    openIndexes.set(event.index, "tool");
-    return;
-  }
-  if (event.type === "hosted_tool_call") {
-    // Hosted tool calls arrive complete: the event opens and closes its
-    // block, so the index only needs to be unused.
-    if (current !== undefined) throw streamContract(`Stream index ${event.index} is already in use.`);
-    return;
-  }
-  if (current !== "tool") {
-    throw streamContract(`Stream index ${event.index} has no open tool call.`);
-  }
-  if (event.type === "tool_call_end") openIndexes.delete(event.index);
-}
-
-export function validateStreamEvent(event: RouterStreamEvent): void {
-  if (!event || typeof event !== "object" || typeof event.type !== "string") {
-    throw streamContract("Executor emitted an invalid stream event.");
-  }
-  if (event.type === "finish") {
-    validateFinishReason(event.finishReason);
-    if (event.usage !== undefined) validateUsage(event.usage);
-    return;
-  }
-  if (!Number.isSafeInteger(event.index) || event.index < 0) {
-    throw streamContract("Executor stream event index must be a non-negative integer.");
-  }
-  if (event.type === "text_delta" || event.type === "tool_call_delta" || event.type === "reasoning_delta") {
-    if (typeof event.delta !== "string" || event.delta.length === 0) {
-      throw streamContract("Executor stream deltas must be non-empty strings.");
-    }
-    return;
-  }
-  if (event.type === "tool_call_start") {
-    if (
-      typeof event.id !== "string" || !event.id.trim() ||
-      typeof event.name !== "string" || !event.name.trim()
-    ) {
-      throw streamContract("Executor tool-call starts require non-empty id and name.");
-    }
-    return;
-  }
-  if (event.type === "hosted_tool_call") {
-    if (
-      typeof event.id !== "string" || event.id.length === 0 ||
-      event.tool !== "web_search" ||
-      event.providerType !== "web_search_call" ||
-      typeof event.payload !== "object" || event.payload === null || Array.isArray(event.payload)
-    ) {
-      throw streamContract("Executor hosted tool calls require id, tool, providerType, and payload.");
-    }
-    return;
-  }
-  if (event.type !== "tool_call_end" && event.type !== "reasoning_end") {
-    throw streamContract(`Executor emitted unsupported stream event '${String((event as { type: unknown }).type)}'.`);
-  }
-}
-
-export function validateCompletion(output: RouterCompletion): void {
-  if (!output || typeof output !== "object" || !Array.isArray(output.content)) {
-    throw new RouterFrameworkError(
-      "executor",
-      "Executor returned an invalid completion.",
-      "executor_output_invalid",
-    );
-  }
-  validateFinishReason(output.finishReason, completionContract);
-  if (output.usage !== undefined) validateUsage(output.usage, completionContract);
-  for (const item of output.content) {
-    if (
-      item && typeof item === "object" && (
-        (item.type === "text" && typeof item.text === "string") ||
-        (
-          item.type === "reasoning" &&
-          typeof item.text === "string" &&
-          (item.redacted === undefined || typeof item.redacted === "boolean") &&
-          (item.source === undefined || (
-            typeof item.source.provider === "string" &&
-            typeof item.source.api === "string" &&
-            typeof item.source.model === "string"
-          )) &&
-          (item.continuation === undefined || (
-            typeof item.continuation === "object" && item.continuation !== null
-          ))
-        ) ||
-        (
-          item.type === "tool_call" &&
-          typeof item.id === "string" && item.id.length > 0 &&
-          typeof item.name === "string" && item.name.length > 0 &&
-          (typeof item.arguments === "string" || (
-            typeof item.arguments === "object" && item.arguments !== null && !Array.isArray(item.arguments)
-          ))
-        ) ||
-        (
-          item.type === "hosted_tool_call" &&
-          typeof item.id === "string" && item.id.length > 0 &&
-          item.tool === "web_search" &&
-          item.providerType === "web_search_call" &&
-          typeof item.payload === "object" && item.payload !== null && !Array.isArray(item.payload)
-        )
-      )
-    ) continue;
-    throw new RouterFrameworkError(
-      "executor",
-      "Executor returned an invalid completion content item.",
-      "executor_output_invalid",
-    );
-  }
-}
-
-function validateFinishReason(
-  value: unknown,
-  contractError: (message: string) => RouterFrameworkError = streamContract,
-): asserts value is RouterFinishReason {
-  if (value !== "stop" && value !== "length" && value !== "tool_calls") {
-    throw contractError("Executor returned an invalid finish reason.");
-  }
-}
-
-function validateUsage(
-  usage: NonNullable<RouterCompletion["usage"]>,
-  contractError: (message: string) => RouterFrameworkError = streamContract,
-): void {
-  if (!usage || typeof usage !== "object") {
-    throw contractError("Executor usage must be an object.");
-  }
-  for (const [name, value, required] of [
-    ["inputTokens", usage.inputTokens, true],
-    ["outputTokens", usage.outputTokens, true],
-    ["cacheReadTokens", usage.cacheReadTokens, false],
-    ["cacheWriteTokens", usage.cacheWriteTokens, false],
-    ["totalTokens", usage.totalTokens, false],
-  ] as const) {
-    if ((required && value === undefined) || (
-      value !== undefined && (!Number.isSafeInteger(value) || value < 0)
-    )) {
-      throw contractError(
-        `Executor usage ${name} must be ${required ? "a" : "an optional"} non-negative integer.`,
-      );
-    }
-  }
-}
-
-export function validatePolicyDecision<Metadata>(
-  value: RoutingPolicyDecision,
-  candidates: readonly RouterCandidate<Metadata>[],
-): RouterSelection<Metadata> {
-  if (!value || typeof value !== "object" || typeof value.model !== "string") {
-    throw new RouterFrameworkError(
-      "policy",
-      "Routing policy returned an invalid decision.",
-      "policy_invalid_decision",
-    );
-  }
-  const candidate = candidates.find((item) => item.id === value.model);
-  if (candidate === undefined) {
-    throw new RouterFrameworkError(
-      "policy",
-      `Routing policy selected unconfigured or ineligible model '${value.model}'.`,
-      "policy_invalid_model",
-    );
-  }
-  const reasoningEffort = value.reasoningEffort ?? candidate.defaultReasoningEffort;
-  if (!isReasoningEffort(reasoningEffort) || !candidate.reasoningEfforts.includes(reasoningEffort)) {
-    throw new RouterFrameworkError(
-      "policy",
-      `Routing policy selected unsupported reasoning effort '${String(reasoningEffort)}' for '${candidate.id}'.`,
-      "policy_invalid_reasoning_effort",
-    );
-  }
-  const reason = typeof value.reason === "string" && value.reason.trim()
-    ? value.reason.trim()
-    : `Routing policy selected ${candidate.id}/${reasoningEffort}.`;
-  const leaseTurnsRemaining = value.leaseTurnsRemaining;
-  if (leaseTurnsRemaining !== undefined && (
-    typeof leaseTurnsRemaining !== "number" ||
-    !Number.isInteger(leaseTurnsRemaining) ||
-    leaseTurnsRemaining < 0
-  )) {
-    throw new RouterFrameworkError(
-      "policy",
-      `Routing policy returned invalid leaseTurnsRemaining '${String(leaseTurnsRemaining)}'.`,
-      "policy_invalid_lease_turns",
-    );
-  }
-  return {
-    decision: {
-      selectedModel: candidate.id,
-      reasoningEffort,
-      reason,
-      ...(leaseTurnsRemaining === undefined ? {} : { leaseTurnsRemaining }),
-    },
-    candidates,
-    ...(value.details === undefined ? {} : { policyDetails: value.details }),
-  };
-}

package/src/json.ts

@@ -1,43 +0,0 @@
-// Small JSON-shape validators shared by modules that consume data across a
-// serialization boundary (recorded routing states, selector inputs, policy
-// completions). Errors read as `<label> <requirement>` so callers can pass
-// precise field paths.
-
-export type JsonValue =
-  | string
-  | number
-  | boolean
-  | null
-  | JsonValue[]
-  | { [key: string]: JsonValue };
-
-export type JsonObject = { [key: string]: JsonValue };
-
-export function requiredString(value: unknown, label: string): string {
-  if (typeof value !== "string" || value.length === 0) {
-    throw new Error(`${label} must be a non-empty string`);
-  }
-  return value;
-}
-
-export function jsonValue(value: unknown, label: string): JsonValue {
-  if (value === undefined) throw new Error(`${label} is missing`);
-  const serialized = JSON.stringify(value);
-  if (serialized === undefined) throw new Error(`${label} is not JSON serializable`);
-  return JSON.parse(serialized) as JsonValue;
-}
-
-export function jsonRecord(value: unknown, label: string): Record<string, JsonValue> {
-  if (typeof value !== "object" || value === null || Array.isArray(value)) {
-    throw new Error(`${label} must be an object`);
-  }
-  return value as Record<string, JsonValue>;
-}
-
-export function withoutKeys(
-  value: Readonly<Record<string, JsonValue>>,
-  keys: readonly string[],
-): JsonObject {
-  const omitted = new Set(keys);
-  return Object.fromEntries(Object.entries(value).filter(([key]) => !omitted.has(key)));
-}

package/src/model_ids.ts

@@ -1,29 +0,0 @@
-import { RouterCoreError } from "./errors.js";
-import type { Provider } from "./types.js";
-
-const PROVIDER_PATTERN = /^[a-z][a-z0-9_.-]{0,119}$/;
-
-export function providerForModel(model: string): Provider {
-  const slash = model.indexOf("/");
-  if (slash <= 0) {
-    throw new RouterCoreError("invalid_request", `Unsupported model provider for ${model}`, "unsupported_model", "model");
-  }
-  const provider = model.slice(0, slash).toLowerCase();
-  if (!PROVIDER_PATTERN.test(provider)) {
-    throw new RouterCoreError("invalid_request", `Unsupported model provider for ${model}`, "unsupported_model", "model");
-  }
-  return provider;
-}
-
-export function nativeModelId(model: string): string {
-  return model.slice(`${providerForModel(model)}/`.length);
-}
-
-// providerForModel() lowercases the provider prefix, so lookups keyed on
-// model ids must use the same canonical spelling; the model segment stays
-// case-sensitive (native ids can be), matching providerForModel semantics.
-export function canonicalModelId(modelId: string): string {
-  const slash = modelId.indexOf("/");
-  if (slash <= 0) return modelId;
-  return modelId.slice(0, slash).toLowerCase() + modelId.slice(slash);
-}