316 lines · 11.7 KB · TypeScript
RawDownload
import { existsSync } from "node:fs";import { dirname, join } from "node:path";import { Effect } from "effect";import type { Config } from "../../config/env";import { resolveBinary } from "../../core/command";import {  isInternalRecipeKey,  isJsonStringArgumentKey,} from "@local-studio/contracts/engine-args";import { getExtraArgument } from "../engines/argument-utilities";import { resolveLlamaBinary } from "../engines/specs/llamacpp-spec";import type { GpuInfo, ProcessInfo, Recipe } from "../models/types";import { resolveRecipeGpuUuids } from "../system/gpu-visibility";import { getGpuInfo } from "../system/platform/gpu";import type { DeviceId, EngineId, InstanceRecord, LaunchFailure } from "./contracts";import {  getDefaultReasoningParser,  getDefaultToolCallParser,  shouldEnableExpertParallel,} from "./recipe-defaults";import type { ComputeLaunchInput, ComputeService } from "./lifecycle";import type { InstanceStore } from "./instances/store"; /** * The legacy-surface bridge: everything the old engine coordinator and process manager * answered — "what is serving on the inference port", "what is launching", launch, * evict, wait-ready — answered from compute instance records instead. One model at a * time is preserved by giving the active model a fixed instance name and serving it on * the legacy inference port, so the proxy, metrics and speech surfaces are unchanged. */ export const LLM_INSTANCE = "llm"; export interface ComputeBridge {  readonly findInferenceProcess: () => Effect.Effect<ProcessInfo | null>;  readonly getCurrentRecipe: () => Effect.Effect<Recipe | null, unknown>;  readonly launchingRecipeId: () => string | null;  readonly launchRecipe: (recipe: Recipe) => Effect.Effect<InstanceRecord, LaunchFailure>;  readonly evict: () => Effect.Effect<boolean>;  readonly cancelLaunch: () => Effect.Effect<boolean>;  readonly waitForHealthy: (timeoutMs: number) => Effect.Effect<boolean>;} export interface ComputeBridgeDependencies {  readonly config: Config;  readonly compute: ComputeService;  readonly store: InstanceStore;  readonly getRecipe: (recipeId: string) => Effect.Effect<Recipe | null, unknown>;} /* ── recipe extra_args -> argv (semantics preserved from the legacy builder) ── */ const normalizeJsonArgument = (value: unknown): unknown => {  if (Array.isArray(value)) return value.map(normalizeJsonArgument);  if (value && typeof value === "object") {    return Object.fromEntries(      Object.entries(value as Record<string, unknown>).map(([key, entry]) => [        key.replace(/-/g, "_"),        normalizeJsonArgument(entry),      ]),    );  }  return value;}; const serializeExtraArgument = (flag: string, key: string, value: unknown): string[] => {  if (value === true) return [flag];  if (value === false) return [];  if (value === undefined || value === null) return [];  if (typeof value === "string" && isJsonStringArgumentKey(key)) {    const trimmed = value.trim();    if (trimmed.startsWith("{") || trimmed.startsWith("[")) {      try {        return [flag, JSON.stringify(normalizeJsonArgument(JSON.parse(trimmed) as unknown))];      } catch {        return [flag, value];      }    }  }  if (Array.isArray(value) || (value && typeof value === "object")) {    return [flag, JSON.stringify(normalizeJsonArgument(value))];  }  return [flag, String(value)];}; export const serializeRecipeExtraArguments = (recipe: Recipe): string[] => {  const argv: string[] = [];  for (const [key, value] of Object.entries(recipe.extra_args ?? {})) {    if (isInternalRecipeKey(key)) continue;    argv.push(...serializeExtraArgument(`--${key.replace(/_/g, "-")}`, key, value));  }  // MoE models on multiple GPUs default to expert parallelism unless the recipe  // explicitly opted out — unchanged vLLM behavior.  if (    recipe.backend === "vllm" &&    !argv.includes("--enable-expert-parallel") &&    shouldEnableExpertParallel(recipe, getExtraArgument(recipe.extra_args, "enable-expert-parallel"))  ) {    argv.push("--enable-expert-parallel");  }  return argv;}; /* ── custom launch command (opt-in arbitrary argv, unchanged policy) ───────── */ const splitLaunchCommand = (command: string): string[] => {  const result: string[] = [];  let current = "";  let quote: string | null = null;  let escaping = false;  for (const character of command) {    if (escaping) {      current += character;      escaping = false;      continue;    }    if (character === "\\") {      escaping = true;      continue;    }    if (quote) {      if (character === quote) quote = null;      else current += character;      continue;    }    if (character === "'" || character === '"') {      quote = character;      continue;    }    if (/\s/.test(character)) {      if (current) {        result.push(current);        current = "";      }      continue;    }    current += character;  }  if (escaping) current += "\\";  if (current) result.push(current);  return result;}; const launchCommandOverride = (recipe: Recipe): string[] | null => {  const override =    getExtraArgument(recipe.extra_args, "launch_command") ??    getExtraArgument(recipe.extra_args, "custom_command");  if (typeof override !== "string" || !override.trim()) return null;  // Arbitrary-binary execution as the controller user; honoured only when the  // operator opted in, exactly as before.  if (process.env["LOCAL_STUDIO_ALLOW_CUSTOM_LAUNCH_COMMAND"] !== "true") return null;  const argv = splitLaunchCommand(override);  return argv.length > 0 ? argv : null;}; /* ── binary resolution per backend ─────────────────────────────────────────── */ const siblingBinary = (pythonPath: string | undefined | null, name: string): string | null => {  if (!pythonPath) return null;  const candidate = join(dirname(pythonPath), name);  return existsSync(candidate) ? candidate : null;}; const resolveEngineBinary = (recipe: Recipe, config: Config): string | null => {  const recipePython = recipe.python_path && existsSync(recipe.python_path) ? recipe.python_path : null;  switch (recipe.backend) {    case "vllm":      return siblingBinary(recipePython, "vllm") ?? resolveBinary("vllm");    case "sglang":      return (        siblingBinary(recipePython ?? config.sglang_python, "sglang") ?? resolveBinary("sglang")      );    case "llamacpp": {      try {        return resolveLlamaBinary(recipe, config);      } catch {        return null;      }    }    case "mlx":      return (        siblingBinary(recipePython ?? config.mlx_python, "mlx_lm.server") ??        resolveBinary("mlx_lm.server")      );    default:      return null;  }}; const resolveRecipeBinary = (recipe: Recipe, config: Config): string | null => {  if (recipe.runtime.kind === "binary" || recipe.runtime.kind === "system") {    return recipe.runtime.ref;  }  if (recipe.runtime.kind === "docker") return null;  return resolveEngineBinary(recipe, config);}; /* ── recipe -> launch input ────────────────────────────────────────────────── */ export const recipeToLaunchInput = (  recipe: Recipe,  config: Config,  devices: readonly DeviceId[],): ComputeLaunchInput => {  const override = launchCommandOverride(recipe);  const toolCallParser = recipe.tool_call_parser ?? getDefaultToolCallParser(recipe) ?? null;  const reasoningParser = recipe.reasoning_parser ?? getDefaultReasoningParser(recipe) ?? null;  const dockerImage = recipe.runtime.kind === "docker" ? recipe.runtime.ref : null;  return {    name: LLM_INSTANCE,    engine: recipe.backend as EngineId,    recipeId: recipe.id,    runtime: dockerImage ? "docker" : "process",    deviceCount: devices.length,    ...(devices.length > 0 ? { devices } : {}),    portOverride: recipe.port || config.inference_port,    modelPath: recipe.model_path,    servedModelName: recipe.served_model_name ?? recipe.model_path,    options: {      tensorParallel: recipe.tensor_parallel_size,      pipelineParallel: recipe.pipeline_parallel_size,      maxContextLength: recipe.max_model_len,      memoryFraction: recipe.gpu_memory_utilization,      maxConcurrentRequests: recipe.max_num_seqs,      kvCacheDtype: recipe.kv_cache_dtype === "auto" ? null : recipe.kv_cache_dtype,      dtype: recipe.dtype ?? null,      quantization: recipe.quantization ?? null,      trustRemoteCode: recipe.trust_remote_code,      toolCallParser,      reasoningParser,    },    extraArgs: serializeRecipeExtraArguments(recipe),    env: recipe.env_vars ?? {},    dockerImage,    binary: resolveRecipeBinary(recipe, config),    ...(override ? { commandOverride: override } : {}),  };}; /* ── the bridge ────────────────────────────────────────────────────────────── */ const RUNNING_STATES = new Set(["starting", "ready", "unhealthy"]); export const createComputeBridge = (deps: ComputeBridgeDependencies): ComputeBridge => {  const llmRecord = (): InstanceRecord | null => deps.store.read(LLM_INSTANCE);   const findInferenceProcess = (): Effect.Effect<ProcessInfo | null> =>    Effect.gen(function* () {      const record = llmRecord();      if (!record || record.ref === null) return null;      const state = yield* deps.compute.stateOf(record);      if (!RUNNING_STATES.has(state)) return null;      const recipe = yield* deps        .getRecipe(record.recipeId)        .pipe(Effect.catch(() => Effect.succeed(null)));      const backend = record.engine === "exllamav3" ? "unknown" : record.engine;      return {        pid: record.ref.kind === "process" ? record.ref.pid : 0,        backend,        model_path: recipe?.model_path ?? null,        port: record.port,        served_model_name: recipe?.served_model_name ?? null,      } satisfies ProcessInfo;    });   const getCurrentRecipe = (): Effect.Effect<Recipe | null, unknown> =>    Effect.gen(function* () {      const record = llmRecord();      if (!record) return null;      return yield* deps.getRecipe(record.recipeId);    });   const launchingRecipeId = (): string | null => {    const record = llmRecord();    if (!record) return null;    // A record without a handle is reserving; with a handle it may still be starting,    // but "launching" for status surfaces means "not yet confirmed running".    return record.ref === null ? record.recipeId : null;  };   const launchRecipe = (recipe: Recipe): Effect.Effect<InstanceRecord, LaunchFailure> =>    Effect.gen(function* () {      const gpus = yield* getGpuInfo().pipe(Effect.catch(() => Effect.succeed([] as GpuInfo[])));      const resolution = resolveRecipeGpuUuids(recipe, gpus);      if (resolution.unresolvedTokens.length > 0) {        return yield* Effect.fail<LaunchFailure>({          kind: "spawn-failed",          detail: `GPU selectors could not be resolved: ${resolution.unresolvedTokens.join(", ")}`,        });      }      return yield* deps.compute.launch(        recipeToLaunchInput(recipe, deps.config, resolution.uuids),      );    });   const waitForHealthy = (timeoutMs: number): Effect.Effect<boolean> =>    Effect.gen(function* () {      const deadline = Date.now() + timeoutMs;      while (Date.now() < deadline) {        const record = llmRecord();        if (record && (yield* deps.compute.stateOf(record)) === "ready") return true;        yield* Effect.sleep(2_000);      }      return false;    });   return {    findInferenceProcess,    getCurrentRecipe,    launchingRecipeId,    launchRecipe,    evict: () => deps.compute.stop(LLM_INSTANCE),    cancelLaunch: () => deps.compute.cancel(LLM_INSTANCE),    waitForHealthy,  };};