veryfront 0.1.498 → 0.1.500

package/src/src/provider/model-registry.ts

@@ -19,10 +19,10 @@ import {
   getGoogleGenAIEnvConfig,
   getOpenAIEnvConfig,
 } from "../config/env.js";
-import { ensureBuiltinAIProviders } from "../extensions/builtin-extensions.js";
+import { ensureBuiltinLLMProviders } from "../extensions/builtin-extensions.js";
 import { tryResolve } from "../extensions/contracts.js";
-import type { AIProviderRegistry } from "../extensions/interfaces/index.js";
-import { AIProviderRegistryName } from "../extensions/interfaces/index.js";
+import type { LLMProviderRegistry } from "../extensions/interfaces/index.js";
+import { LLMProviderRegistryName } from "../extensions/interfaces/index.js";
 import { ProjectScopedRegistryManager } from "../registry/project-scoped-registry-manager.js";
 import { serverLogger } from "../utils/index.js";
 import { DEFAULT_LOCAL_MODEL } from "./local/model-catalog.js";
@@ -91,7 +91,7 @@ function autoInitializeFromEnv(): void {
           }),
         );
       }
-      const registry = ensureBuiltinAIProviders();
+      const registry = ensureBuiltinLLMProviders();
       const provider = registry.get("openai");
       if (provider) {
         return provider.createModel(id, {
@@ -101,7 +101,8 @@ function autoInitializeFromEnv(): void {
       }
       throw toError(createError({
         type: "config",
-        message: "OpenAI provider not installed. Add @veryfront/ext-openai to use openai/* models.",
+        message:
+          "OpenAI provider not installed. Add @veryfront/ext-llm-openai to use openai/* models.",
       }));
     });
   }
@@ -118,7 +119,7 @@ function autoInitializeFromEnv(): void {
           }),
         );
       }
-      const registry = ensureBuiltinAIProviders();
+      const registry = ensureBuiltinLLMProviders();
       const provider = registry.get("anthropic");
       if (provider) {
         return provider.createModel(id, {
@@ -129,7 +130,7 @@ function autoInitializeFromEnv(): void {
       throw toError(createError({
         type: "config",
         message:
-          "Anthropic provider not installed. Add @veryfront/ext-anthropic to use anthropic/* models.",
+          "Anthropic provider not installed. Add @veryfront/ext-llm-anthropic to use anthropic/* models.",
       }));
     });
   }
@@ -146,7 +147,7 @@ function autoInitializeFromEnv(): void {
           }),
         );
       }
-      const registry = ensureBuiltinAIProviders();
+      const registry = ensureBuiltinLLMProviders();
       const provider = registry.get("google");
       if (provider) {
         return provider.createModel(id, {
@@ -157,7 +158,7 @@ function autoInitializeFromEnv(): void {
         createError({
           type: "config",
           message:
-            "Google provider not installed. Add @veryfront/ext-google to use google/* models.",
+            "Google provider not installed. Add @veryfront/ext-llm-google to use google/* models.",
         }),
       );
     });
@@ -233,7 +234,7 @@ function isMissingProviderConfiguration(errorData: ReturnType<typeof fromError>)
  */
 export function findAvailableCloudModel(): string | null {
   autoInitializeFromEnv();
-  const registry = tryResolve<AIProviderRegistry>(AIProviderRegistryName);
+  const registry = tryResolve<LLMProviderRegistry>(LLMProviderRegistryName);
   for (const { provider, model, hasKey } of CLOUD_UPGRADE_CANDIDATES) {
     if (!hasKey()) continue;
     if (!manager.has(provider)) continue;

package/src/src/provider/shared/index.ts

@@ -3,7 +3,7 @@
  *
  * This barrel is the stable public surface: implementations currently live
  * in `runtime-loader.ts` and `runtime-loader/` subdirectory. Future PRs
- * (post ext-anthropic / ext-google extraction) may move the implementations
+ * (post ext-llm-anthropic / ext-llm-google extraction) may move the implementations
  * into this directory; extensions keep importing from here unchanged.
  *
  * @module provider/shared

package/src/src/provider/veryfront-cloud/openai.ts

@@ -1,7 +1,7 @@
 import type { EmbeddingRuntime, ModelRuntime } from "../types.js";
-import { OpenAIProvider } from "../../../extensions/ext-openai/src/index.js";
+import { OpenAIProvider } from "../../../extensions/ext-llm-openai/src/index.js";
 
-const openAIProvider = new OpenAIProvider();
+const openLLMProvider = new OpenAIProvider();
 
 interface VeryfrontCloudOpenAIConfig {
   apiToken: string;
@@ -13,7 +13,7 @@ export function createVeryfrontCloudOpenAIModel(
   modelId: string,
   config: VeryfrontCloudOpenAIConfig,
 ): ModelRuntime {
-  return openAIProvider.createModel(modelId, {
+  return openLLMProvider.createModel(modelId, {
     credential: config.apiToken,
     baseURL: config.baseURL,
     name: "veryfront-cloud",
@@ -25,7 +25,7 @@ export function createVeryfrontCloudOpenAIEmbeddingModel(
   modelId: string,
   config: VeryfrontCloudOpenAIConfig,
 ): EmbeddingRuntime {
-  return openAIProvider.createEmbedding(modelId, {
+  return openLLMProvider.createEmbedding(modelId, {
     credential: config.apiToken,
     baseURL: config.baseURL,
     name: "veryfront-cloud",

package/src/src/provider/veryfront-cloud/provider.ts

@@ -1,5 +1,5 @@
 import { createError, toError } from "../../errors/veryfront-error.js";
-import { ensureBuiltinAIProviders } from "../../extensions/builtin-extensions.js";
+import { ensureBuiltinLLMProviders } from "../../extensions/builtin-extensions.js";
 import type { ModelRuntime } from "../types.js";
 import {
   createVeryfrontCloudFetch,
@@ -14,7 +14,7 @@ export function createVeryfrontCloudModel(modelId: string): ModelRuntime {
   const { apiBaseUrl, apiToken, projectSlug } = requireVeryfrontCloudBootstrap();
   const baseURL = getVeryfrontCloudGatewayBaseUrl(apiBaseUrl, provider);
   const fetch = createVeryfrontCloudFetch(apiToken, projectSlug);
-  const registry = ensureBuiltinAIProviders();
+  const registry = ensureBuiltinLLMProviders();
 
   switch (provider) {
     case "anthropic": {

package/src/src/server/bootstrap.ts

@@ -3,8 +3,10 @@ import type { VeryfrontConfig } from "../config/index.js";
 import type { InvalidationProjectContext } from "../platform/adapters/fs/veryfront/types.js";
 import { clearConfigCache, getConfig } from "../config/index.js";
 import { type ExtensionLoader, orchestrateExtensions, tryResolve } from "../extensions/index.js";
-import { AIProviderRegistryName } from "../extensions/interfaces/index.js";
-import { createAIProviderRegistry } from "../extensions/registries/ai-provider-registry.js";
+import {
+  createLLMProviderRegistry,
+  LLMProviderRegistryName,
+} from "../extensions/llm/index.js";
 import { createBuiltinExtensions } from "../extensions/builtin-extensions.js";
 import { MISSING_EXTENSION_ERROR } from "../extensions/errors.js";
 import { getRecommendation } from "../extensions/recommendations.js";
@@ -281,7 +283,7 @@ export async function bootstrap(
         projectDir,
         config,
         logger: bootstrapLog,
-        primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
+        primeContracts: { [LLMProviderRegistryName]: createLLMProviderRegistry() },
         builtinExtensions: createBuiltinExtensions(),
       });
       wireTracingShim();
@@ -325,7 +327,7 @@ export async function bootstrap(
         projectDir,
         config,
         logger: bootstrapLog,
-        primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
+        primeContracts: { [LLMProviderRegistryName]: createLLMProviderRegistry() },
         builtinExtensions: createBuiltinExtensions(),
       });
       wireTracingShim();
@@ -398,7 +400,7 @@ export async function bootstrap(
           projectDir,
           config,
           logger: bootstrapLog,
-          primeContracts: { [AIProviderRegistryName]: createAIProviderRegistry() },
+          primeContracts: { [LLMProviderRegistryName]: createLLMProviderRegistry() },
           builtinExtensions: createBuiltinExtensions(),
         }),
       fsDispose,

package/src/src/server/handlers/request/api/project-discovery.ts

@@ -1,5 +1,5 @@
 import { serverLogger } from "../../../../utils/index.js";
-import { clearTrackedAgents } from "../../../../discovery/index.js";
+import { clearTrackedAgents, createProjectDiscoveryConfig } from "../../../../discovery/index.js";
 import { tryGetCacheKeyContext } from "../../../../cache/cache-key-builder.js";
 import type { HandlerContext } from "../../types.js";
 
@@ -16,31 +16,6 @@ const logger = serverLogger.component("api-wrapper");
  */
 const discoveredProjects = new Map<string, Promise<void>>();
 
-function isDiscoveryEnabled(
-  discovery: { enabled?: boolean } | undefined,
-): boolean {
-  return discovery?.enabled ?? true;
-}
-
-function buildDiscoveryConfig(ctx: HandlerContext) {
-  const discoveryConfig = ctx.config?.ai;
-  const toolDiscovery = discoveryConfig?.tools?.discovery;
-  const agentDiscovery = discoveryConfig?.agents?.discovery;
-  const skillDiscovery = discoveryConfig?.skills?.discovery;
-
-  return {
-    baseDir: ctx.projectDir,
-    toolDirs: isDiscoveryEnabled(toolDiscovery) ? (toolDiscovery?.paths ?? ["tools"]) : [],
-    agentDirs: isDiscoveryEnabled(agentDiscovery) ? (agentDiscovery?.paths ?? ["agents"]) : [],
-    skillDirs: isDiscoveryEnabled(skillDiscovery) ? (skillDiscovery?.paths ?? ["skills"]) : [],
-    resourceDirs: ["resources"],
-    promptDirs: ["prompts"],
-    workflowDirs: ["workflows"],
-    fsAdapter: ctx.adapter.fs,
-    verbose: false,
-  };
-}
-
 /** Build a discovery cache key that incorporates the release/version. */
 function discoveryKey(ctx: HandlerContext): string {
   const cacheContext = tryGetCacheKeyContext();
@@ -99,7 +74,11 @@ export async function ensureProjectDiscovery(ctx: HandlerContext): Promise<void>
     agentRegistry.clear();
     toolRegistry.clear();
 
-    const discoveryOptions = buildDiscoveryConfig(ctx);
+    const discoveryOptions = createProjectDiscoveryConfig({
+      projectDir: ctx.projectDir,
+      config: ctx.config,
+      fsAdapter: ctx.adapter.fs,
+    });
     const result = await discoverAll(discoveryOptions);
     const shouldWarnOnEmptyAiDiscovery = discoveryOptions.toolDirs.length > 0 ||
       discoveryOptions.agentDirs.length > 0;

package/src/src/server/index.ts

@@ -65,11 +65,15 @@ export {
   type NodeVeryfrontServiceServer,
   startNodeVeryfrontServer,
   type StartNodeVeryfrontServerOptions,
+  startVeryfrontServer,
+  type StartVeryfrontServerOptions,
+  type VeryfrontServiceServer,
   type VeryfrontServiceServerFetch,
   type VeryfrontServiceServerLogger,
   type VeryfrontServiceServerModule,
   type VeryfrontServiceServerModuleResponse,
   type VeryfrontServiceServerRuntime,
+  type VeryfrontServiceServerRuntimeKind,
 } from "./service-server.js";
 export type {
   DevServerOptions,

package/src/src/server/service-server.ts

@@ -43,12 +43,80 @@ export type StartNodeVeryfrontServerOptions = {
   hardShutdownTimeoutMs?: number;
 };
 
+export type StartVeryfrontServerOptions = {
+  runtime: VeryfrontServiceServerRuntime;
+  port: number;
+  bindAddress?: string;
+  logger?: VeryfrontServiceServerLogger;
+  signals?: readonly NodeJS.Signals[];
+  hardShutdownTimeoutMs?: number;
+};
+
+export type VeryfrontServiceServerRuntimeKind = "node" | "deno" | "bun";
+
+export type VeryfrontServiceServer = {
+  ready: Promise<void>;
+  stop: () => Promise<void>;
+  port: number;
+  url: string;
+  runtime: VeryfrontServiceServerRuntimeKind;
+};
+
 export type NodeVeryfrontServiceServer = {
   server: import("node:http").Server;
   ready: Promise<void>;
   stop: () => Promise<void>;
   port: number;
   url: string;
+  runtime: "node";
+};
+
+type DenoServeOptions = {
+  port: number;
+  hostname?: string;
+  signal?: AbortSignal;
+  onListen?: (address: { port: number; hostname: string }) => void;
+};
+
+type DenoServeHandler = (request: Request) => Response | Promise<Response>;
+
+type DenoHttpServer = {
+  addr?: {
+    port?: number;
+  };
+  finished?: Promise<void>;
+  shutdown?: () => void | Promise<void>;
+};
+
+type DenoServeRuntime = {
+  serve: (options: DenoServeOptions, handler: DenoServeHandler) => DenoHttpServer;
+  addSignalListener?: (signal: NodeJS.Signals, handler: SignalHandler) => void;
+  removeSignalListener?: (signal: NodeJS.Signals, handler: SignalHandler) => void;
+  exit?: (code: number) => never | void;
+};
+
+type BunServeOptions = {
+  port: number;
+  hostname?: string;
+  fetch: VeryfrontServiceServerFetch;
+};
+
+type BunHttpServer = {
+  port?: number;
+  url?: URL;
+  stop?: () => void | Promise<void>;
+};
+
+type BunServeRuntime = {
+  serve: (options: BunServeOptions) => BunHttpServer;
+};
+
+type SignalHandler = () => void;
+
+type SignalRuntime = {
+  add: (signal: NodeJS.Signals, handler: SignalHandler) => void;
+  remove?: (signal: NodeJS.Signals, handler: SignalHandler) => void;
+  exit?: (code: number) => never | void;
 };
 
 function defaultNotFound(): Response {
@@ -116,6 +184,365 @@ function closeNodeServer(server: import("node:http").Server): Promise<void> {
   });
 }
 
+function isObject(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null;
+}
+
+function isDenoHttpServer(value: unknown): value is DenoHttpServer {
+  if (!isObject(value)) {
+    return false;
+  }
+  const finished = value.finished;
+  const shutdown = value.shutdown;
+  const addr = value.addr;
+  const port = isObject(addr) ? addr.port : undefined;
+  return (addr === undefined || isObject(addr)) &&
+    (port === undefined || typeof port === "number") &&
+    (finished === undefined || finished instanceof Promise) &&
+    (shutdown === undefined || typeof shutdown === "function");
+}
+
+function isBunHttpServer(value: unknown): value is BunHttpServer {
+  if (!isObject(value)) {
+    return false;
+  }
+  const port = value.port;
+  const url = value.url;
+  const stop = value.stop;
+  return (port === undefined || typeof port === "number") &&
+    (url === undefined || url instanceof URL) &&
+    (stop === undefined || typeof stop === "function");
+}
+
+function getDenoServeRuntime(): DenoServeRuntime | null {
+  const denoGlobal: unknown = Reflect.get(dntShim.dntGlobalThis, "Deno");
+  if (!isObject(denoGlobal)) {
+    return null;
+  }
+  const serve = denoGlobal.serve;
+  const addSignalListener = denoGlobal.addSignalListener;
+  const removeSignalListener = denoGlobal.removeSignalListener;
+  const exit = denoGlobal.exit;
+  if (typeof serve !== "function") {
+    return null;
+  }
+  const runtime: DenoServeRuntime = {
+    serve: (options, handler) => {
+      const server: unknown = Reflect.apply(serve, denoGlobal, [options, handler]);
+      if (!isDenoHttpServer(server)) {
+        return {};
+      }
+      return server;
+    },
+  };
+  if (typeof addSignalListener === "function") {
+    runtime.addSignalListener = (signal, handler) => {
+      Reflect.apply(addSignalListener, denoGlobal, [signal, handler]);
+    };
+  }
+  if (typeof removeSignalListener === "function") {
+    runtime.removeSignalListener = (signal, handler) => {
+      Reflect.apply(removeSignalListener, denoGlobal, [signal, handler]);
+    };
+  }
+  if (typeof exit === "function") {
+    runtime.exit = (code) => Reflect.apply(exit, denoGlobal, [code]);
+  }
+  return runtime;
+}
+
+function getBunServeRuntime(): BunServeRuntime | null {
+  const bunGlobal: unknown = Reflect.get(dntShim.dntGlobalThis, "Bun");
+  if (!isObject(bunGlobal)) {
+    return null;
+  }
+  const serve = bunGlobal.serve;
+  if (typeof serve !== "function") {
+    return null;
+  }
+  return {
+    serve: (options) => {
+      const server: unknown = Reflect.apply(serve, bunGlobal, [options]);
+      if (!isBunHttpServer(server)) {
+        return {};
+      }
+      return server;
+    },
+  };
+}
+
+function getProcessSignalRuntime(): SignalRuntime | null {
+  const processGlobal: unknown = Reflect.get(dntShim.dntGlobalThis, "process");
+  if (!isObject(processGlobal)) {
+    return null;
+  }
+  const on = processGlobal.on;
+  const off = processGlobal.off;
+  const removeListener = processGlobal.removeListener;
+  const exit = processGlobal.exit;
+  if (typeof on !== "function") {
+    return null;
+  }
+  const runtime: SignalRuntime = {
+    add: (signal, handler) => {
+      Reflect.apply(on, processGlobal, [signal, handler]);
+    },
+  };
+  if (typeof off === "function") {
+    runtime.remove = (signal, handler) => {
+      Reflect.apply(off, processGlobal, [signal, handler]);
+    };
+  } else if (typeof removeListener === "function") {
+    runtime.remove = (signal, handler) => {
+      Reflect.apply(removeListener, processGlobal, [signal, handler]);
+    };
+  }
+  if (typeof exit === "function") {
+    runtime.exit = (code) => Reflect.apply(exit, processGlobal, [code]);
+  }
+  return runtime;
+}
+
+function createDenoSignalRuntime(deno: DenoServeRuntime): SignalRuntime | null {
+  if (!deno.addSignalListener) {
+    return null;
+  }
+  return {
+    add: deno.addSignalListener,
+    remove: deno.removeSignalListener,
+    exit: deno.exit,
+  };
+}
+
+function resolveRuntimeKind(): VeryfrontServiceServerRuntimeKind {
+  if (getBunServeRuntime()) {
+    return "bun";
+  }
+  if (getDenoServeRuntime()) {
+    return "deno";
+  }
+  return "node";
+}
+
+async function stopRuntime(
+  runtime: VeryfrontServiceServerRuntime,
+  stopServer: () => void | Promise<void>,
+): Promise<void> {
+  runtime.setShuttingDown();
+  await stopServer();
+  await runtime.stop();
+}
+
+function installSignalHandlers(options: {
+  signalRuntime: SignalRuntime | null;
+  signals?: readonly NodeJS.Signals[];
+  logger: VeryfrontServiceServerLogger;
+  stop: () => Promise<void>;
+  hardShutdownTimeoutMs?: number;
+  runtime: VeryfrontServiceServerRuntimeKind;
+}): () => void {
+  if (!options.signalRuntime) {
+    return () => undefined;
+  }
+
+  const hardShutdownTimeoutMs = options.hardShutdownTimeoutMs ?? 20_000;
+  const installedHandlers: Array<{ signal: NodeJS.Signals; handler: SignalHandler }> = [];
+  let signalShutdownStarted = false;
+
+  for (const signal of options.signals ?? ["SIGTERM"]) {
+    const handler = () => {
+      if (signalShutdownStarted) {
+        return;
+      }
+
+      signalShutdownStarted = true;
+      options.logger.info?.("Veryfront service server received shutdown signal", {
+        signal,
+        runtime: options.runtime,
+      });
+      const hardTimeout = dntShim.setTimeout(() => {
+        options.logger.error?.("Veryfront service server graceful shutdown timed out", {
+          signal,
+          runtime: options.runtime,
+        });
+        options.signalRuntime?.exit?.(1);
+      }, hardShutdownTimeoutMs);
+
+      void options.stop()
+        .then(() => {
+          clearTimeout(hardTimeout);
+          options.signalRuntime?.exit?.(0);
+        })
+        .catch((error: unknown) => {
+          clearTimeout(hardTimeout);
+          options.logger.error?.("Veryfront service server shutdown failed", {
+            signal,
+            runtime: options.runtime,
+            error: error instanceof Error ? error.message : String(error),
+          });
+          options.signalRuntime?.exit?.(1);
+        });
+    };
+
+    try {
+      options.signalRuntime.add(signal, handler);
+      installedHandlers.push({ signal, handler });
+    } catch (error) {
+      options.logger.warn?.("Veryfront service server could not install shutdown signal handler", {
+        signal,
+        runtime: options.runtime,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  }
+
+  return () => {
+    for (const { signal, handler } of installedHandlers) {
+      try {
+        options.signalRuntime?.remove?.(signal, handler);
+      } catch (error) {
+        options.logger.warn?.("Veryfront service server could not remove shutdown signal handler", {
+          signal,
+          runtime: options.runtime,
+          error: error instanceof Error ? error.message : String(error),
+        });
+      }
+    }
+  };
+}
+
+async function startDenoVeryfrontServer(
+  options: StartVeryfrontServerOptions,
+  deno: DenoServeRuntime,
+): Promise<VeryfrontServiceServer> {
+  const logger = options.logger ?? serverLogger.component("service-server");
+  const bindAddress = options.bindAddress ?? "0.0.0.0";
+  const abortController = new AbortController();
+  const server = deno.serve({
+    port: options.port,
+    hostname: bindAddress,
+    signal: abortController.signal,
+    onListen: () => undefined,
+  }, options.runtime.fetch);
+  let shutdownStarted = false;
+  let removeSignalHandlers: () => void = () => undefined;
+
+  const stop = async () => {
+    if (shutdownStarted) {
+      return;
+    }
+
+    shutdownStarted = true;
+    try {
+      await stopRuntime(options.runtime, async () => {
+        if (server.shutdown) {
+          await server.shutdown();
+          return;
+        }
+        abortController.abort();
+        await server.finished?.catch(() => undefined);
+      });
+    } finally {
+      removeSignalHandlers();
+    }
+  };
+
+  removeSignalHandlers = installSignalHandlers({
+    signalRuntime: createDenoSignalRuntime(deno),
+    signals: options.signals,
+    logger,
+    stop,
+    hardShutdownTimeoutMs: options.hardShutdownTimeoutMs,
+    runtime: "deno",
+  });
+
+  logger.info?.("Veryfront service server listening", {
+    port: server.addr?.port ?? options.port,
+    bindAddress,
+    runtime: "deno",
+  });
+
+  return {
+    ready: Promise.resolve(),
+    stop,
+    port: server.addr?.port ?? options.port,
+    url: `http://${bindAddress}:${server.addr?.port ?? options.port}`,
+    runtime: "deno",
+  };
+}
+
+async function startBunVeryfrontServer(
+  options: StartVeryfrontServerOptions,
+  bun: BunServeRuntime,
+): Promise<VeryfrontServiceServer> {
+  const logger = options.logger ?? serverLogger.component("service-server");
+  const bindAddress = options.bindAddress ?? "0.0.0.0";
+  const server = bun.serve({
+    port: options.port,
+    hostname: bindAddress,
+    fetch: options.runtime.fetch,
+  });
+  let shutdownStarted = false;
+  let removeSignalHandlers: () => void = () => undefined;
+
+  const stop = async () => {
+    if (shutdownStarted) {
+      return;
+    }
+
+    shutdownStarted = true;
+    try {
+      await stopRuntime(options.runtime, async () => {
+        await server.stop?.();
+      });
+    } finally {
+      removeSignalHandlers();
+    }
+  };
+
+  removeSignalHandlers = installSignalHandlers({
+    signalRuntime: getProcessSignalRuntime(),
+    signals: options.signals,
+    logger,
+    stop,
+    hardShutdownTimeoutMs: options.hardShutdownTimeoutMs,
+    runtime: "bun",
+  });
+
+  logger.info?.("Veryfront service server listening", {
+    port: server.port ?? options.port,
+    bindAddress,
+    runtime: "bun",
+  });
+
+  return {
+    ready: Promise.resolve(),
+    stop,
+    port: server.port ?? options.port,
+    url: server.url?.toString() ?? `http://${bindAddress}:${options.port}`,
+    runtime: "bun",
+  };
+}
+
+export async function startVeryfrontServer(
+  options: StartVeryfrontServerOptions,
+): Promise<VeryfrontServiceServer | NodeVeryfrontServiceServer> {
+  const runtimeKind = resolveRuntimeKind();
+  if (runtimeKind === "bun") {
+    const bun = getBunServeRuntime();
+    if (bun) {
+      return await startBunVeryfrontServer(options, bun);
+    }
+  }
+  if (runtimeKind === "deno") {
+    const deno = getDenoServeRuntime();
+    if (deno) {
+      return await startDenoVeryfrontServer(options, deno);
+    }
+  }
+  return await startNodeVeryfrontServer(options);
+}
+
 export async function startNodeVeryfrontServer(
   options: StartNodeVeryfrontServerOptions,
 ): Promise<NodeVeryfrontServiceServer> {
@@ -183,5 +610,6 @@ export async function startNodeVeryfrontServer(
     stop,
     port: options.port,
     url: `http://${bindAddress}:${options.port}`,
+    runtime: "node",
   };
 }

package/src/src/utils/version-constant.ts

@@ -1,3 +1,3 @@
 // Keep in sync with deno.json version.
 // scripts/release.ts updates this constant during releases.
-export const VERSION = "0.1.498";
+export const VERSION = "0.1.500";