fix: added back retrieval of registered providers

Signed-off-by: Brian <[email protected]>

Author: bmahabirbu

packages/backend/src/managers/inference/inferenceManager.ts

@@ -98,6 +98,15 @@ export class InferenceManager extends Publisher<InferenceServer[]> implements Di
     return Array.from(this.#servers.values());
   }
 
+  /**
+   * Get the Unique registered Inference provider types
+   */
+
+  public getRegisteredProviders(): InferenceType[] {
+    const types: InferenceType[] = this.inferenceProviderRegistry.getAll().map(provider => provider.type);
+    return [...new Set(types)];
+  }
+
   /**
    * return an inference server
    * @param containerId the containerId of the inference server

packages/backend/src/studio-api-impl.ts

@@ -30,7 +30,7 @@ import type { TaskRegistry } from './registries/TaskRegistry';
 import type { LocalRepository } from '@shared/models/ILocalRepository';
 import type { LocalRepositoryRegistry } from './registries/LocalRepositoryRegistry';
 import path from 'node:path';
-import type { InferenceServer } from '@shared/models/IInference';
+import type { InferenceServer, InferenceType } from '@shared/models/IInference';
 import type { CreationInferenceServerOptions } from '@shared/models/InferenceServerConfig';
 import type { InferenceManager } from './managers/inference/inferenceManager';
 import type { Conversation } from '@shared/models/IPlaygroundMessage';
@@ -144,6 +144,10 @@ export class StudioApiImpl implements StudioAPI {
     return this.inferenceManager.getServers();
   }
 
+  async getRegisteredProviders(): Promise<InferenceType[]> {
+    return this.inferenceManager.getRegisteredProviders();
+  }
+
   async requestDeleteInferenceServer(...containerIds: string[]): Promise<void> {
     // Do not wait on the promise as the api would probably timeout before the user answer.
     if (containerIds.length === 0) throw new Error('At least one container id should be provided.');

packages/frontend/src/lib/select/InferenceRuntimeSelect.spec.ts

@@ -22,8 +22,7 @@ import { render, fireEvent, within } from '@testing-library/svelte';
 import InferenceRuntimeSelect from '/@/lib/select/InferenceRuntimeSelect.svelte';
 import { InferenceType } from '@shared/models/IInference';
 
-const getFilteredOptions = (exclude: InferenceType[] = []): InferenceType[] =>
-  Object.values(InferenceType).filter(type => !exclude.includes(type));
+const providers: InferenceType[] = [InferenceType.LLAMA_CPP, InferenceType.OPENVINO, InferenceType.WHISPER_CPP];
 
 beforeEach(() => {
   // mock scrollIntoView
@@ -33,14 +32,15 @@ beforeEach(() => {
 test('Lists all runtime options', async () => {
   const { container } = render(InferenceRuntimeSelect, {
     value: undefined,
+    providers,
     disabled: false,
   });
 
   const input = within(container).getByLabelText('Select Inference Runtime');
   await fireEvent.pointerUp(input);
 
   const items = container.querySelectorAll('div[class~="list-item"]');
-  const expectedOptions = getFilteredOptions();
+  const expectedOptions = providers;
 
   expect(items.length).toBe(expectedOptions.length);
 
@@ -52,14 +52,15 @@ test('Lists all runtime options', async () => {
 test('Selected value should be visible', async () => {
   const { container } = render(InferenceRuntimeSelect, {
     value: undefined,
+    providers,
     disabled: false,
   });
 
   const input = within(container).getByLabelText('Select Inference Runtime');
   await fireEvent.pointerUp(input);
 
   const items = container.querySelectorAll('div[class~="list-item"]');
-  const expectedOptions = getFilteredOptions();
+  const expectedOptions = providers;
 
   await fireEvent.click(items[0]);
 
@@ -75,6 +76,7 @@ test('Exclude specific runtime from list', async () => {
 
   const { container } = render(InferenceRuntimeSelect, {
     value: undefined,
+    providers,
     disabled: false,
     exclude: excluded,
   });
@@ -89,7 +91,7 @@ test('Exclude specific runtime from list', async () => {
     expect(itemTexts).not.toContain(excludedType);
   });
 
-  const expected = getFilteredOptions(excluded);
+  const expected = providers.filter(type => !excluded.includes(type));
 
   expected.forEach(included => {
     expect(itemTexts).toContain(included);

packages/frontend/src/lib/select/InferenceRuntimeSelect.svelte

@@ -1,16 +1,19 @@
 <script lang="ts">
 import Select from '/@/lib/select/Select.svelte';
-import { InferenceType } from '@shared/models/IInference';
+import type { InferenceType } from '@shared/models/IInference';
 
 interface Props {
   disabled?: boolean;
   value: InferenceType | undefined;
+  providers: InferenceType[];
   exclude?: InferenceType[];
 }
+let { value = $bindable(), disabled, providers, exclude = [] }: Props = $props();
 
-let { value = $bindable(), disabled, exclude = [] }: Props = $props();
-
-const options = Object.values(InferenceType).filter(type => !exclude.includes(type));
+// Filter options based on optional exclude list
+const options = $derived(() =>
+  providers.filter(type => !exclude.includes(type)).map(type => ({ value: type, label: type })),
+);
 
 function handleOnChange(nValue: { value: string } | undefined): void {
   if (nValue) {
@@ -28,7 +31,4 @@ function handleOnChange(nValue: { value: string } | undefined): void {
   value={value ? { label: value, value: value } : undefined}
   onchange={handleOnChange}
   placeholder="Select Inference Runtime to use"
-  items={options.map(type => ({
-    value: type,
-    label: type,
-  }))} />
+  items={options()} />

packages/frontend/src/pages/PlaygroundCreate.spec.ts

@@ -72,6 +72,7 @@ vi.mock('../utils/client', async () => {
     studioClient: {
       requestCreatePlayground: vi.fn(),
       getExtensionConfiguration: vi.fn().mockResolvedValue({}),
+      getRegisteredProviders: vi.fn().mockResolvedValue([]),
     },
     rpcBrowser: {
       subscribe: (): unknown => {
@@ -100,6 +101,11 @@ beforeEach(() => {
 
   const tasksList = writable<Task[]>([]);
   vi.mocked(tasksStore).tasks = tasksList;
+  vi.mocked(studioClient.getRegisteredProviders).mockResolvedValue([
+    InferenceType.LLAMA_CPP,
+    InferenceType.WHISPER_CPP,
+    InferenceType.OPENVINO,
+  ]);
 });
 
 test('model should be selected by default when runtime is set', async () => {

packages/frontend/src/pages/PlaygroundCreate.svelte

@@ -23,7 +23,12 @@ let runtime: InferenceType | undefined = undefined;
 // Exlude certain runtimes from selection
 export let exclude: InferenceType[] = [InferenceType.NONE, InferenceType.WHISPER_CPP];
 
-onMount(() => {
+// Get registered list of providers
+let providers: InferenceType[] = [];
+
+onMount(async () => {
+  providers = await studioClient.getRegisteredProviders();
+
   const inferenceRuntime = $configuration?.inferenceRuntime;
   if (
     Object.values(InferenceType).includes(inferenceRuntime as InferenceType) &&
@@ -170,7 +175,7 @@ export function goToUpPage(): void {
           <label for="inference-runtime" class="pt-4 block mb-2 font-bold text-[var(--pd-content-card-header-text)]">
             Inference Runtime
           </label>
-          <InferenceRuntimeSelect bind:value={runtime} exclude={exclude} />
+          <InferenceRuntimeSelect bind:value={runtime} providers={providers} exclude={exclude} />
 
           <!-- model input -->
           <label for="model" class="pt-4 block mb-2 font-bold text-[var(--pd-content-card-header-text)]">Model</label>

packages/shared/src/StudioAPI.ts

@@ -17,6 +17,7 @@
  ***********************************************************************/
 
 import type { ModelInfo } from './models/IModelInfo';
+import type { InferenceType } from '@shared/models/IInference';
 import type { ApplicationCatalog } from './models/IApplicationCatalog';
 import type { OpenDialogOptions, Uri } from '@podman-desktop/api';
 import type { ApplicationState } from './models/IApplicationState';
@@ -121,6 +122,11 @@ export interface StudioAPI {
    */
   getInferenceServers(): Promise<InferenceServer[]>;
 
+  /**
+   * Get inference providers
+   */
+  getRegisteredProviders(): Promise<InferenceType[]>;
+
   /**
    * Request to start an inference server
    * @param options The options to use