Add list_models caching across all SDK languages (nodejs, dotnet, go)

Co-authored-by: friggeri <106686+friggeri@users.noreply.github.com>

Author: Copilot

dotnet/src/Client.cs

@@ -58,6 +58,8 @@ public partial class CopilotClient : IDisposable, IAsyncDisposable
     private bool _disposed;
     private readonly int? _optionsPort;
     private readonly string? _optionsHost;
+    private List<ModelInfo>? _modelsCache;
+    private readonly SemaphoreSlim _modelsCacheLock = new(1, 1);
 
     /// <summary>
     /// Creates a new instance of <see cref="CopilotClient"/>.
@@ -284,6 +286,9 @@ private async Task CleanupConnectionAsync(List<Exception>? errors)
         try { ctx.Rpc.Dispose(); }
         catch (Exception ex) { errors?.Add(ex); }
 
+        // Clear models cache
+        _modelsCache = null;
+
         if (ctx.NetworkStream is not null)
         {
             try { await ctx.NetworkStream.DisposeAsync(); }
@@ -543,15 +548,38 @@ public async Task<GetAuthStatusResponse> GetAuthStatusAsync(CancellationToken ca
     /// </summary>
     /// <param name="cancellationToken">A <see cref="CancellationToken"/> that can be used to cancel the operation.</param>
     /// <returns>A task that resolves with a list of available models.</returns>
+    /// <remarks>
+    /// Results are cached after the first successful call to avoid rate limiting.
+    /// The cache is cleared when the client disconnects.
+    /// </remarks>
     /// <exception cref="InvalidOperationException">Thrown when the client is not connected or not authenticated.</exception>
     public async Task<List<ModelInfo>> ListModelsAsync(CancellationToken cancellationToken = default)
     {
         var connection = await EnsureConnectedAsync(cancellationToken);
 
-        var response = await InvokeRpcAsync<GetModelsResponse>(
-            connection.Rpc, "models.list", [], cancellationToken);
+        // Use semaphore for async locking to prevent race condition with concurrent calls
+        await _modelsCacheLock.WaitAsync(cancellationToken);
+        try
+        {
+            // Check cache (already inside lock)
+            if (_modelsCache is not null)
+            {
+                return new List<ModelInfo>(_modelsCache); // Return a copy to prevent cache mutation
+            }
+
+            // Cache miss - fetch from backend while holding lock
+            var response = await InvokeRpcAsync<GetModelsResponse>(
+                connection.Rpc, "models.list", [], cancellationToken);
+
+            // Update cache before releasing lock
+            _modelsCache = response.Models;
 
-        return response.Models;
+            return new List<ModelInfo>(response.Models); // Return a copy to prevent cache mutation
+        }
+        finally
+        {
+            _modelsCacheLock.Release();
+        }
     }
 
     /// <summary>

go/client.go

@@ -74,6 +74,8 @@ type Client struct {
 	useStdio         bool        // resolved value from options
 	autoStart        bool        // resolved value from options
 	autoRestart      bool        // resolved value from options
+	modelsCache      []ModelInfo
+	modelsCacheMux   sync.Mutex
 }
 
 // NewClient creates a new Copilot CLI client with the given options.
@@ -324,6 +326,11 @@ func (c *Client) Stop() []error {
 		c.client = nil
 	}
 
+	// Clear models cache
+	c.modelsCacheMux.Lock()
+	c.modelsCache = nil
+	c.modelsCacheMux.Unlock()
+
 	c.state = StateDisconnected
 	if !c.isExternalServer {
 		c.actualPort = 0
@@ -380,6 +387,11 @@ func (c *Client) ForceStop() {
 		c.client = nil
 	}
 
+	// Clear models cache
+	c.modelsCacheMux.Lock()
+	c.modelsCache = nil
+	c.modelsCacheMux.Unlock()
+
 	c.state = StateDisconnected
 	if !c.isExternalServer {
 		c.actualPort = 0
@@ -1007,12 +1019,28 @@ func (c *Client) GetAuthStatus() (*GetAuthStatusResponse, error) {
 	return response, nil
 }
 
-// ListModels returns available models with their metadata
+// ListModels returns available models with their metadata.
+//
+// Results are cached after the first successful call to avoid rate limiting.
+// The cache is cleared when the client disconnects.
 func (c *Client) ListModels() ([]ModelInfo, error) {
 	if c.client == nil {
 		return nil, fmt.Errorf("client not connected")
 	}
 
+	// Use mutex for locking to prevent race condition with concurrent calls
+	c.modelsCacheMux.Lock()
+	defer c.modelsCacheMux.Unlock()
+
+	// Check cache (already inside lock)
+	if c.modelsCache != nil {
+		// Return a copy to prevent cache mutation
+		result := make([]ModelInfo, len(c.modelsCache))
+		copy(result, c.modelsCache)
+		return result, nil
+	}
+
+	// Cache miss - fetch from backend while holding lock
 	result, err := c.client.Request("models.list", map[string]interface{}{})
 	if err != nil {
 		return nil, err
@@ -1029,7 +1057,13 @@ func (c *Client) ListModels() ([]ModelInfo, error) {
 		return nil, fmt.Errorf("failed to unmarshal models response: %w", err)
 	}
 
-	return response.Models, nil
+	// Update cache before releasing lock
+	c.modelsCache = response.Models
+
+	// Return a copy to prevent cache mutation
+	models := make([]ModelInfo, len(response.Models))
+	copy(models, response.Models)
+	return models, nil
 }
 
 // verifyProtocolVersion verifies that the server's protocol version matches the SDK's expected version

nodejs/src/client.ts

@@ -112,6 +112,8 @@ export class CopilotClient {
     };
     private isExternalServer: boolean = false;
     private forceStopping: boolean = false;
+    private modelsCache: ModelInfo[] | null = null;
+    private modelsCacheLock: Promise<void> = Promise.resolve();
 
     /**
      * Creates a new CopilotClient instance.
@@ -315,6 +317,9 @@ export class CopilotClient {
             this.connection = null;
         }
 
+        // Clear models cache
+        this.modelsCache = null;
+
         if (this.socket) {
             try {
                 this.socket.end();
@@ -389,6 +394,9 @@ export class CopilotClient {
             this.connection = null;
         }
 
+        // Clear models cache
+        this.modelsCache = null;
+
         if (this.socket) {
             try {
                 this.socket.destroy(); // destroy() is more forceful than end()
@@ -638,17 +646,44 @@ export class CopilotClient {
     }
 
     /**
-     * List available models with their metadata
+     * List available models with their metadata.
+     *
+     * Results are cached after the first successful call to avoid rate limiting.
+     * The cache is cleared when the client disconnects.
+     *
      * @throws Error if not authenticated
      */
     async listModels(): Promise<ModelInfo[]> {
         if (!this.connection) {
             throw new Error("Client not connected");
         }
 
-        const result = await this.connection.sendRequest("models.list", {});
-        const response = result as { models: ModelInfo[] };
-        return response.models;
+        // Use promise-based locking to prevent race condition with concurrent calls
+        await this.modelsCacheLock;
+
+        let resolveLock: () => void;
+        this.modelsCacheLock = new Promise((resolve) => {
+            resolveLock = resolve;
+        });
+
+        try {
+            // Check cache (already inside lock)
+            if (this.modelsCache !== null) {
+                return [...this.modelsCache]; // Return a copy to prevent cache mutation
+            }
+
+            // Cache miss - fetch from backend while holding lock
+            const result = await this.connection.sendRequest("models.list", {});
+            const response = result as { models: ModelInfo[] };
+            const models = response.models;
+
+            // Update cache before releasing lock
+            this.modelsCache = models;
+
+            return [...models]; // Return a copy to prevent cache mutation
+        } finally {
+            resolveLock!();
+        }
     }
 
     /**