Address pull-request review comments

Author: baijumeswani

sdk/cs/src/EpInfo.cs

@@ -13,7 +13,7 @@ namespace Microsoft.AI.Foundry.Local;
 /// </summary>
 public record EpInfo
 {
-    /// <summary>The display name of the bootstrapper (e.g. "CUDA Execution Provider").</summary>
+    /// <summary>The identifier of the bootstrapper/execution provider (e.g. "CUDAExecutionProvider").</summary>
     [JsonPropertyName("Name")]
     public required string Name { get; init; }
 

sdk/cs/src/FoundryLocalManager.cs

@@ -173,6 +173,20 @@ public async Task<EpDownloadResult> DownloadAndRegisterEpsAsync(IEnumerable<stri
                                                     .ConfigureAwait(false);
     }
 
+    /// <summary>
+    /// Deprecated compatibility wrapper for <see cref="DownloadAndRegisterEpsAsync(IEnumerable{string}?, CancellationToken?)"/>.
+    /// </summary>
+    /// <param name="names">
+    /// Optional subset of EP bootstrapper names to download (as returned by <see cref="DiscoverEps"/>).
+    /// If null or empty, all discoverable EPs are downloaded.
+    /// </param>
+    /// <param name="ct">Optional cancellation token.</param>
+    [Obsolete("EnsureEpsDownloadedAsync has been replaced by DownloadAndRegisterEpsAsync and will be removed in a future release.")]
+    public async Task EnsureEpsDownloadedAsync(IEnumerable<string>? names = null, CancellationToken? ct = null)
+    {
+        _ = await DownloadAndRegisterEpsAsync(names, ct).ConfigureAwait(false);
+    }
+
     private FoundryLocalManager(Configuration configuration, ILogger logger)
     {
         _config = configuration ?? throw new ArgumentNullException(nameof(configuration));

sdk/js/README.md

@@ -42,15 +42,15 @@ You can explicitly discover and download execution providers using the `discover
 // Discover available EPs and their status
 const eps = manager.discoverEps();
 for (const ep of eps) {
-    console.log(`${ep.Name} — registered: ${ep.IsRegistered}`);
+    console.log(`${ep.name} — registered: ${ep.isRegistered}`);
 }
 
 // Download and register all available EPs
 const result = manager.downloadAndRegisterEps();
-console.log(`Success: ${result.Success}, Status: ${result.Status}`);
+console.log(`Success: ${result.success}, Status: ${result.status}`);
 
 // Download only specific EPs
-const result2 = manager.downloadAndRegisterEps([eps[0].Name]);
+const result2 = manager.downloadAndRegisterEps([eps[0].name]);
 ```
 
 Catalog access does not block on EP downloads. Call `downloadAndRegisterEps()` when you need hardware-accelerated execution providers.

sdk/js/docs/README.md

@@ -153,6 +153,70 @@ object: string;
 
 ***
 
+### EpDownloadResult
+
+Result of an explicit EP download and registration operation.
+
+#### Properties
+
+##### failedEps
+
+```ts
+failedEps: string[];
+```
+
+Names of EPs that failed to register.
+
+##### registeredEps
+
+```ts
+registeredEps: string[];
+```
+
+Names of EPs that were successfully registered.
+
+##### status
+
+```ts
+status: string;
+```
+
+Human-readable status message.
+
+##### success
+
+```ts
+success: boolean;
+```
+
+True if all requested EPs were successfully downloaded and registered.
+
+***
+
+### EpInfo
+
+Describes a discoverable execution provider bootstrapper.
+
+#### Properties
+
+##### isRegistered
+
+```ts
+isRegistered: boolean;
+```
+
+True if this EP has already been successfully downloaded and registered.
+
+##### name
+
+```ts
+name: string;
+```
+
+The identifier of the bootstrapper/execution provider (e.g. "CUDAExecutionProvider").
+
+***
+
 ### FoundryLocalConfig
 
 Configuration options for the Foundry Local SDK.

sdk/js/docs/classes/FoundryLocalManager.md

@@ -87,6 +87,44 @@ Error - If the web service is not running.
 
 ***
 
+### discoverEps()
+
+```ts
+discoverEps(): EpInfo[];
+```
+
+Discovers available execution providers (EPs) and their registration status.
+
+#### Returns
+
+[`EpInfo`](../README.md#epinfo)[]
+
+An array of EpInfo describing each available EP.
+
+***
+
+### downloadAndRegisterEps()
+
+```ts
+downloadAndRegisterEps(names?): EpDownloadResult;
+```
+
+Downloads and registers execution providers. This is a blocking call.
+
+#### Parameters
+
+| Parameter | Type | Description |
+| ------ | ------ | ------ |
+| `names?` | `string`[] | Optional array of EP names to download. If omitted, all available EPs are downloaded. |
+
+#### Returns
+
+[`EpDownloadResult`](../README.md#epdownloadresult)
+
+An EpDownloadResult with the outcome of the operation.
+
+***
+
 ### startWebService()
 
 ```ts

sdk/js/examples/chat-completion.ts

@@ -4,21 +4,31 @@
 // -------------------------------------------------------------------------
 
 import { FoundryLocalManager } from '../src/index.js';
-import path from 'path';
 
 async function main() {
-    let modelToLoad: any = null;
-
     try {
         // Initialize the Foundry Local SDK
         console.log('Initializing Foundry Local SDK...');
 
+        // NOTE: You must update libraryPath to point to your built DLL if not in standard location
         const manager = FoundryLocalManager.create({
-            appName: 'FoundryLocalAudioExample',
+            appName: 'FoundryLocalExample',
+            serviceEndpoint: 'http://localhost:5000',
             logLevel: 'info'
         });
         console.log('✓ SDK initialized successfully');
 
+        const availableEps = manager.discoverEps();
+        console.log(`\nAvailable execution providers: ${availableEps.map((ep) => ep.name).join(', ')}`);
+
+        console.log('\nDownloading and registering execution providers...');
+        const downloadResult = await manager.downloadAndRegisterEps();
+        if (downloadResult.success) {
+            console.log('✓ All execution providers registered successfully');
+        } else {
+            console.log(`⚠️ Some execution providers failed to download and/or register: ${downloadResult.failedEps.join(', ')}`);
+        }
+
         // Explore available models
         console.log('\nFetching available models...');
         const catalog = manager.catalog;
@@ -30,45 +40,44 @@ async function main() {
             console.log(`  - ${model.alias} (variants: ${variants})`);
         }
 
-        const modelAlias = 'whisper-medium';
+        // Explore cached models
+        console.log('\nFetching cached models...');
+        const cachedModels = await catalog.getCachedModels();
+        console.log(`Found ${cachedModels.length} cached models:`);
+        for (const cachedModel of cachedModels) {
+            console.log(`  - ${cachedModel.alias}`);
+        }
+
+        const modelAlias = 'MODEL_ALIAS'; // Replace with a valid model alias from the list above
 
-        // Get the Whisper model
+        // Load the model first
         console.log(`\nLoading model ${modelAlias}...`);
-        modelToLoad = await catalog.getModel(modelAlias);
+        const modelToLoad = await catalog.getModel(modelAlias);
         if (!modelToLoad) {
             throw new Error(`Model ${modelAlias} not found`);
         }
 
-        // Download if not cached
-        if (!modelToLoad.isCached) {
-            console.log('Downloading model...');
-            await modelToLoad.download((progress: number) => {
-                process.stdout.write(`\rDownload: ${progress.toFixed(1)}%`);
-            });
-            console.log();
-        }
-
         await modelToLoad.load();
         console.log('✓ Model loaded');
 
-        // Create audio client
-        console.log('\nCreating audio client...');
-        const audioClient = modelToLoad.createAudioClient();
+        // Create chat client
+        console.log('\nCreating chat client...');
+        const chatClient = modelToLoad.createChatClient();
 
-        // Configure settings
-        audioClient.settings.language = 'en';
-        // audioClient.settings.temperature = 0.0; // deterministic results
+        // Configure chat settings
+        chatClient.settings.temperature = 0.7;
+        chatClient.settings.maxTokens = 800;
 
-        console.log('✓ Audio client created');
+        console.log('✓ Chat client created');
 
-        // Audio file path — update this to point to your audio file
-        const audioFilePath = path.join(process.cwd(), '..', 'testdata', 'Recording.mp3');
+        // Example chat completion
+        console.log('\nTesting chat completion...');
+        const completion = await chatClient.completeChat([
+            { role: 'user', content: 'What is the capital of France?' }
+        ]);
 
-        // Example: Standard transcription
-        console.log('\nTesting standard transcription...');
-        const result = await audioClient.transcribe(audioFilePath);
-        console.log('\nTranscription result:');
-        console.log(result.text);
+        console.log('\nChat completion result:');
+        console.log(completion.choices[0]?.message?.content);
 
         // Example streaming completion
         console.log('\nTesting streaming completion...');
@@ -82,27 +91,33 @@ async function main() {
         }
         console.log('\n');
 
-        // Unload the model
-        console.log('Unloading model...');
-        await modelToLoad.unload();
-        console.log(`✓ Model unloaded`);
+        // Model management example
+        const model = await catalog.getModel(modelAlias);
+        if (model) {
+            console.log('\nModel management example:');
+            // Already loaded above, but let's check status
+            console.log(`Checking model: ${model.id}`);
+            console.log(`✓ Model loaded: ${await model.isLoaded()}`);
+            
+            // Unload when done
+            console.log('Unloading model...');
+            await model.unload();
+            console.log(`✓ Model loaded: ${await model.isLoaded()}`);
+        }
 
-        console.log('\n✓ Audio transcription example completed successfully');
+        console.log('\n✓ Example completed successfully');
 
     } catch (error) {
         console.log('Error running example:', error);
+        // Print stack trace if available
         if (error instanceof Error && error.stack) {
             console.log(error.stack);
         }
-        // Best-effort cleanup
-        if (modelToLoad) {
-            try { await modelToLoad.unload(); } catch { /* ignore */ }
-        }
         process.exit(1);
     }
 }
 
 // Run the example
 main().catch(console.error);
 
-export { main };
+export { main };

sdk/js/src/foundryLocalManager.ts

@@ -101,8 +101,17 @@ export class FoundryLocalManager {
      */
     public discoverEps(): EpInfo[] {
         const response = this.coreInterop.executeCommand("discover_eps");
+        type RawEpInfo = {
+            Name: string;
+            IsRegistered: boolean;
+        };
+
         try {
-            return JSON.parse(response) as EpInfo[];
+            const raw = JSON.parse(response) as RawEpInfo[];
+            return raw.map((ep) => ({
+                name: ep.Name,
+                isRegistered: ep.IsRegistered
+            }));
         } catch (error) {
             throw new Error(`Failed to decode JSON response from discover_eps: ${error}. Response was: ${response}`);
         }
@@ -114,13 +123,27 @@ export class FoundryLocalManager {
      * @returns An EpDownloadResult with the outcome of the operation.
      */
     public downloadAndRegisterEps(names?: string[]): EpDownloadResult {
-        const params: any = {};
+        const params: { Params?: { Names: string } } = {};
         if (names && names.length > 0) {
             params.Params = { Names: names.join(",") };
         }
         const response = this.coreInterop.executeCommand("download_and_register_eps", Object.keys(params).length > 0 ? params : undefined);
+
+        type RawEpDownloadResult = {
+            Success: boolean;
+            Status: string;
+            RegisteredEps: string[];
+            FailedEps: string[];
+        };
+
         try {
-            return JSON.parse(response) as EpDownloadResult;
+            const raw = JSON.parse(response) as RawEpDownloadResult;
+            return {
+                success: raw.Success,
+                status: raw.Status,
+                registeredEps: raw.RegisteredEps,
+                failedEps: raw.FailedEps
+            };
         } catch (error) {
             throw new Error(`Failed to decode JSON response from download_and_register_eps: ${error}. Response was: ${response}`);
         }

sdk/js/src/types.ts

@@ -73,22 +73,22 @@ export interface ToolChoice {
 
 /** Describes a discoverable execution provider bootstrapper. */
 export interface EpInfo {
-    /** The display name of the bootstrapper (e.g. "CUDA Execution Provider"). */
-    Name: string;
+    /** The identifier of the bootstrapper/execution provider (e.g. "CUDAExecutionProvider"). */
+    name: string;
     /** True if this EP has already been successfully downloaded and registered. */
-    IsRegistered: boolean;
+    isRegistered: boolean;
 }
 
 /** Result of an explicit EP download and registration operation. */
 export interface EpDownloadResult {
     /** True if all requested EPs were successfully downloaded and registered. */
-    Success: boolean;
+    success: boolean;
     /** Human-readable status message. */
-    Status: string;
+    status: string;
     /** Names of EPs that were successfully registered. */
-    RegisteredEps: string[];
+    registeredEps: string[];
     /** Names of EPs that failed to register. */
-    FailedEps: string[];
+    failedEps: string[];
 }
 
 // ============================================================================